Files
aevolution/tests/cellular_publication_tests.cpp
T
dingoandClaude Opus 5.5 4130092d7a End dead lives durably so a player can start again
M11.6a (ADR-0127, schema v37): a published life is marked ended once, by a
commit of its region, through the lease-fenced end_cellular_lives. One active
life per account replaces one life per account, so after a death the account
reserves and publishes a new primitive founder while the corpse, archive and
descendants stay. The host records endings after the death's publication and
again for every founder corpse on recovery. The cellular server now refuses only
an unusable carried action, not the whole tick.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-14 07:26:33 -04:00

1049 lines
51 KiB
C++

// Profile-4 publication and recovery against the migration-backed PostgreSQL adapter.
#include "evo/persistence/account_control_store.hpp"
#include "evo/persistence/checkpoint_store.hpp"
#include "evo/persistence/life_reservation_store.hpp"
#include "evo/persistence/sha256.hpp"
#include "evo/server/cellular_region_host.hpp"
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <optional>
#include <source_location>
#include <stdexcept>
void run_cellular_publication_tests();
namespace {
using namespace evo::persistence;
using namespace evo::server;
using namespace std::chrono_literals;
void check(bool value, std::source_location at = std::source_location::current()) {
if (!value)
throw std::runtime_error("cellular publication test line " + std::to_string(at.line()));
}
#define CHECK(...) check(static_cast<bool>(__VA_ARGS__))
template <typename T> const T& checked_value(const std::optional<T>& value) {
if (!value.has_value())
throw std::runtime_error("cellular publication test expected an optional value");
return *value;
}
template <typename T, typename E> const T& checked_value(const std::expected<T, E>& value) {
if (!value.has_value())
throw std::runtime_error("cellular publication test expected a successful result");
return *value;
}
std::string env(const char* name) {
const auto* value = std::getenv(name);
if (!value)
throw std::runtime_error("missing PostgreSQL test environment");
return value;
}
auto connect_as(const std::string& user) {
auto db =
Postgres::connect({env("PGHOST"), {}, env("PGPORT"), env("PGDATABASE"), user, {}, {}}, 5s);
CHECK(db);
return std::move(*db);
}
template <std::size_t N> std::array<std::uint8_t, N> filled(std::uint8_t value) {
std::array<std::uint8_t, N> out{};
out.fill(value);
return out;
}
// Commit ids are unique across the whole store; other suites use uniform-byte ids, so
// these mix bytes.
Uuid distinct_commit(std::uint8_t tag) {
auto id = filled<16>(0xC3);
id[1] = 0x5E;
id[15] = tag;
return id;
}
std::string hex(std::span<const std::uint8_t> bytes) {
constexpr char digits[] = "0123456789abcdef";
std::string out = "\\x";
for (const auto byte : bytes) {
out.push_back(digits[byte >> 4U]);
out.push_back(digits[byte & 15U]);
}
return out;
}
void refresh_cellular_checksum(std::vector<std::uint8_t>& bytes) {
std::uint64_t value = 14695981039346656037ULL;
for (const auto byte : std::span{bytes}.first(bytes.size() - 8))
value = (value ^ byte) * 1099511628211ULL;
for (unsigned index = 0; index < 8; ++index)
bytes[bytes.size() - 8 + index] = static_cast<std::uint8_t>(value >> (index * 8U));
}
} // namespace
namespace {
void cellular_birth_publication_is_durable() {
using namespace evo::biology;
constexpr RegionKey key{9758, 1};
auto owner = connect_as(env("PGUSER"));
auto runtime = connect_as(env("EVO_PG_RUNTIME_USER"));
const auto build = filled<32>(0xD9);
CHECK(owner->query("INSERT INTO evolution.retained_builds(build_identity) VALUES "
"(decode(repeat('d9',32),'hex')) ON CONFLICT DO NOTHING",
{}, 5s));
auto endowed = primitive_endowment();
CHECK(endowed);
auto funding = endowed->body;
funding.energy.value = endowed->reserve.energy.value + endowed->construction.value;
auto primitive = PrimitiveLives::create({key.world, key.region, 1, 17, funding, {{0, 0}}});
CHECK(primitive);
auto habitat = CellularHabitat::create({key.world, key.region, 1, 1'000, 1'000, {}});
CHECK(habitat);
auto opening =
CellularLives::create(**primitive, std::move(*habitat), {{1'000, 1'000}, 0, 293'150});
CHECK(opening && (*opening)->lives().empty());
auto objects = FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(objects);
const auto genesis = provision_cellular_region(*owner, **objects, key, 1, **opening,
filled<16>(0x30), build, 5s);
CHECK(genesis);
CHECK(owner->query("INSERT INTO evolution.life_allocators VALUES(9758,1000)", {}, 5s));
const auto connect = [&]() -> std::expected<std::unique_ptr<Postgres>, PgFailure> {
return Postgres::connect({env("PGHOST"),
{},
env("PGPORT"),
env("PGDATABASE"),
env("EVO_PG_RUNTIME_USER"),
{},
{}},
5s);
};
// A fresh value per host: copying the config trips a GCC 14 -O3 array-bounds false positive.
const auto config = [&] { return CellularHostConfig{key, 1, {}, build, {build}}; };
auto made = CellularRegionHost::create(config(), connect, std::move(*objects));
CHECK(made);
auto host = std::move(*made);
CHECK(host->step().ready);
const auto authority = host->authority();
CHECK(authority);
const auto& authority_value = checked_value(authority);
const auto committed = host->committed();
CHECK(committed);
const auto& committed_value = checked_value(committed);
const auto account = filled<16>(0x47);
const auto control =
claim_account_control(*runtime, key, authority_value, account, 1, 1, 20'000ms, 5s);
CHECK(control);
const auto requested = host->create_primitive_life(account, control->generation, 7);
CHECK(requested.result == evo::network::PrimitiveLifeResult::pending &&
requested.life_identity != 0 && host->queued_births().size() == 1);
const auto retried = host->create_primitive_life(account, control->generation, 7);
CHECK(retried == requested && host->queued_births().size() == 1);
const auto reservation = host->queued_births().front();
CellularBatch batch;
const auto predecessor_digest = sha256(committed_value.manifest);
CHECK(predecessor_digest);
batch.header = {
key.world, key.region, 1, committed_value.head.commit, checked_value(predecessor_digest),
0, 1};
CellularTickIntents tick;
tick.births.push_back(reservation);
batch.ticks.push_back(tick);
auto candidate = replay_cellular_batch(*host->state(), batch);
CHECK(candidate && (*candidate)->lives().size() == 1 &&
(*candidate)->lives()[0].identity.life == reservation.identity);
auto published = host->publish(batch);
if (!published) {
const auto& failure = published.error();
auto message = "cellular host publish failed, error=" +
std::to_string(static_cast<unsigned>(failure.kind));
if (failure.publication)
message +=
", publication=" + std::to_string(static_cast<unsigned>(*failure.publication));
if (failure.store) {
message += ", store=" + std::to_string(static_cast<unsigned>(failure.store->kind));
const auto& state = failure.store->cause.sqlstate;
if (state[0] != '\0')
message += ", sqlstate=" + std::string(state.data(), 5);
}
if (failure.object)
message += ", object=" + std::to_string(static_cast<unsigned>(*failure.object));
throw std::runtime_error(message);
}
CHECK(published->committed.head.sequence == 1);
CHECK(host->state()->snapshot() == (*candidate)->snapshot());
CHECK(host->queued_births().empty());
const auto host_outcome = host->query_primitive_life(account, control->generation, 7);
CHECK(host_outcome.result == evo::network::PrimitiveLifeResult::born &&
host_outcome.life_identity == reservation.identity && host_outcome.commit_sequence == 1);
const auto outcome =
query_primitive_life(*runtime, key, authority_value, account, control->generation, 7, 5s);
CHECK(outcome && outcome.value().has_value());
const auto& outcome_value = checked_value(outcome.value());
CHECK(outcome_value.published.has_value());
const auto& published_value = checked_value(outcome_value.published);
CHECK(published_value.identity == reservation.identity && published_value.born == 1);
host->drain();
host.reset();
auto restarted_objects =
FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(restarted_objects);
auto restarted_made =
CellularRegionHost::create(config(), connect, std::move(*restarted_objects));
CHECK(restarted_made);
auto restarted = std::move(*restarted_made);
CHECK(restarted->step().ready && restarted->state()->tick() == 1 &&
restarted->state()->snapshot() == (*candidate)->snapshot());
restarted->drain();
}
void cellular_profile_migration_is_durable_and_recovers_without_a_tick() {
using namespace evo::biology;
constexpr RegionKey key{9759, 1};
auto owner = connect_as(env("PGUSER"));
const auto build = filled<32>(0xD9);
CHECK(owner->query("INSERT INTO evolution.retained_builds(build_identity) VALUES "
"(decode(repeat('d9',32),'hex')) ON CONFLICT DO NOTHING",
{}, 5s));
auto endowment = primitive_endowment();
CHECK(endowment);
auto funding = endowment->body;
funding.energy.value += endowment->reserve.energy.value + endowment->construction.value;
for (std::size_t index = 0; index < funding.matter.size(); ++index)
funding.matter[index].value += endowment->reserve.matter[index].value;
auto primitive = PrimitiveLives::create({key.world, key.region, 1, 17, funding, {{0, 0}}});
CHECK(primitive);
auto habitat = CellularHabitat::create({key.world, key.region, 1, 1'000, 1'000, {}});
CHECK(habitat);
auto current =
CellularLives::create(**primitive, std::move(*habitat), {{1'000, 1'000}, 0, 293'150});
CHECK(current && (*current)->lives().empty());
auto legacy_bytes = (*current)->snapshot();
constexpr std::uint64_t legacy_magic = 0x3130564C43564541ULL;
for (unsigned index = 0; index < 8; ++index)
legacy_bytes[index] = static_cast<std::uint8_t>(legacy_magic >> (index * 8U));
legacy_bytes[8] = 1;
legacy_bytes[9] = legacy_bytes[10] = legacy_bytes[11] = 0;
legacy_bytes[12] = 1;
legacy_bytes[13] = legacy_bytes[14] = legacy_bytes[15] = 0;
refresh_cellular_checksum(legacy_bytes);
auto legacy = CellularLives::restore(legacy_bytes, key.world, key.region, 1, 0);
CHECK(legacy && (*legacy)->format_version() == cellular_lives_legacy_format);
auto objects = FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(objects);
auto genesis_commit = filled<16>(0x50);
genesis_commit[0] = 0x51;
auto provisioned =
provision_cellular_region(*owner, **objects, key, 1, **legacy, genesis_commit, build, 5s);
CHECK(provisioned);
CHECK(owner->query("INSERT INTO evolution.life_allocators VALUES(9759,1000) "
"ON CONFLICT DO NOTHING",
{}, 5s));
const auto connect = [&]() -> std::expected<std::unique_ptr<Postgres>, PgFailure> {
return Postgres::connect({env("PGHOST"),
{},
env("PGPORT"),
env("PGDATABASE"),
env("EVO_PG_RUNTIME_USER"),
{},
{}},
5s);
};
// A fresh value per host: copying the config trips a GCC 14 -O3 array-bounds false positive.
const auto config = [&] { return CellularHostConfig{key, 1, {}, build, {build}}; };
auto migration_objects =
FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(migration_objects);
auto made = CellularRegionHost::create(config(), connect, std::move(*objects));
CHECK(made);
auto host = std::move(*made);
CHECK(host->step().ready);
const auto authority = host->authority();
CHECK(authority);
const auto& authority_value = checked_value(authority);
const auto predecessor = host->committed();
CHECK(predecessor);
const auto& predecessor_value = checked_value(predecessor);
CHECK(predecessor_value.head.sequence == 0);
auto runtime = connect_as(env("EVO_PG_RUNTIME_USER"));
const auto account = filled<16>(0x5A);
const auto control =
claim_account_control(*runtime, key, authority_value, account, 1, 1, 20'000ms, 5s);
CHECK(control);
const auto requested = host->create_primitive_life(account, control->generation, 9);
CHECK(requested.result == evo::network::PrimitiveLifeResult::pending &&
requested.life_identity != 0 && host->queued_births().size() == 1);
CellularBatch batch;
const auto predecessor_digest = sha256(predecessor_value.manifest);
CHECK(predecessor_digest);
batch.header = {
key.world, key.region, 1, predecessor_value.head.commit, checked_value(predecessor_digest),
0, 1};
CellularTickIntents tick;
tick.births.push_back(host->queued_births().front());
batch.ticks.push_back(tick);
const auto published = host->publish(batch);
CHECK(published && published->committed.head.sequence == 1);
CHECK(host->state()->lives().size() == 1 &&
host->state()->lives().front().identity.born.value == 1);
auto migrated =
migrate_cellular_profile_to_v2(*owner, **migration_objects, authority_value,
published->committed, filled<16>(0x51), build, 5s);
CHECK(migrated && migrated->head.sequence == 2 && migrated->head.end_tick == 1);
CHECK(
retry_cellular_profile_migration(*owner, {key, filled<16>(0x51), migrated->manifest}, 5s));
auto revision_migrated = migrate_cellular_profile_to_v3(
*owner, **migration_objects, authority_value, *migrated, filled<16>(0x52), build, 5s);
CHECK(revision_migrated && revision_migrated->head.sequence == 3 &&
revision_migrated->head.end_tick == 1);
CHECK(retry_cellular_profile_migration(
*owner, {key, filled<16>(0x52), revision_migrated->manifest}, 5s));
host->drain();
host.reset();
auto recovery_objects =
FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(recovery_objects);
const auto target_manifest = decode_manifest(revision_migrated->manifest);
CHECK(target_manifest);
const auto target_payload =
(*recovery_objects)->get({target_manifest->payload_sha256, target_manifest->payload_bytes});
CHECK(target_payload);
auto restarted_made =
CellularRegionHost::create(config(), connect, std::move(*recovery_objects));
CHECK(restarted_made);
auto restarted = std::move(*restarted_made);
CHECK(restarted->step().ready);
const auto restarted_committed = restarted->committed();
CHECK(restarted_committed);
const auto& restarted_committed_value = checked_value(restarted_committed);
CHECK(restarted_committed_value.head.sequence == 3 &&
restarted_committed_value.head.end_tick == 1 && restarted->state()->tick() == 1 &&
restarted->state()->format_version() == cellular_lives_revision_format &&
restarted->state()->snapshot() == *target_payload);
restarted->drain();
}
// ADR-0121 (schema v35): a reserved mutation choice publishes with its checkpoint, the
// bound result is the replay's, recovery reloads choice and result, and a restarted host
// resumes at the same state.
void cellular_mutation_publication_binds_results() {
using namespace evo::biology;
constexpr RegionKey key{9764, 1};
auto owner = connect_as(env("PGUSER"));
auto runtime = connect_as(env("EVO_PG_RUNTIME_USER"));
const auto build = filled<32>(0xD9);
CHECK(owner->query("INSERT INTO evolution.retained_builds(build_identity) VALUES "
"(decode(repeat('d9',32),'hex')) ON CONFLICT DO NOTHING",
{}, 5s));
auto endowed = primitive_endowment();
CHECK(endowed);
auto funding = endowed->body;
funding.energy.value = endowed->reserve.energy.value + endowed->construction.value;
auto primitive = PrimitiveLives::create({key.world, key.region, 1, 17, funding, {{0, 0}}});
CHECK(primitive);
// A stocked patch under the spawn site feeds the cell to its first offer.
constexpr std::uint64_t stock = 100'000'000;
auto habitat = CellularHabitat::create(
{key.world,
key.region,
1,
1'000,
1'000,
{{{0, 0}, 29, {{stock}, {{{stock}, {stock}, {stock}, {stock}}}}}}});
CHECK(habitat);
auto opening =
CellularLives::create(**primitive, std::move(*habitat), {{1'000, 1'000}, 0, 293'150},
CellularLivesProfile::engulf);
CHECK(opening);
auto objects = FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(objects);
CHECK(provision_cellular_region(*owner, **objects, key, 1, **opening, distinct_commit(0x9A),
build, 5s));
CHECK(owner->query("INSERT INTO evolution.life_allocators VALUES(9764,1000) "
"ON CONFLICT DO NOTHING",
{}, 5s));
const auto connect = [&]() -> std::expected<std::unique_ptr<Postgres>, PgFailure> {
return Postgres::connect({env("PGHOST"),
{},
env("PGPORT"),
env("PGDATABASE"),
env("EVO_PG_RUNTIME_USER"),
{},
{}},
5s);
};
// A fresh value per host: copying the config trips a GCC 14 -O3 array-bounds false positive.
const auto config = [&] { return CellularHostConfig{key, 1, {}, build, {build}}; };
auto made = CellularRegionHost::create(config(), connect, std::move(*objects));
CHECK(made);
auto host = std::move(*made);
CHECK(host->step().ready);
const auto authority = checked_value(host->authority());
const auto account = filled<16>(0x64);
const auto control =
claim_account_control(*runtime, key, authority, account, 1, 1, 60'000ms, 5s);
CHECK(control);
CHECK(host->create_primitive_life(account, control->generation, 11).result ==
evo::network::PrimitiveLifeResult::pending);
// Each batch starts at the host's committed head.
const auto header = [&](std::uint64_t ticks) {
const auto& committed = checked_value(host->committed());
const auto digest = sha256(committed.manifest);
CHECK(digest);
return CellularBatchHeader{key.world,
key.region,
1,
committed.head.commit,
checked_value(digest),
host->state()->tick(),
host->state()->tick() + ticks};
};
CellularBatch birth;
birth.header = header(1);
birth.ticks.push_back({{}, {host->queued_births().front()}, {}});
CHECK(host->publish(birth));
const auto life_id = host->state()->lives().front().identity.life;
for (int round = 0; round < 4 && !host->state()->lives().front().mutation.offer; ++round) {
CHECK(host->step().ready);
CellularBatch feeding;
feeding.header = header(64);
CellularStepIntent feed{};
feed.intake_target = CellularPatchAddress{0, 0};
for (int tick = 0; tick < 64; ++tick)
feeding.ticks.push_back({{{life_id, feed}}, {}, {}});
CHECK(host->publish(feeding));
}
const auto& life = host->state()->lives().front();
CHECK(life.mutation.offer.has_value());
const auto offer = checked_value(life.mutation.offer);
CellularMutationActionRecord choice;
choice.account = account;
choice.action_id = 21;
choice.tick = host->state()->tick() + 1;
choice.input = {life_id, life.mutation.event_index, life.mutation.offer_tick,
offer.candidates.front().operator_id};
const auto reservation =
reserve_cellular_mutation(*runtime, key, authority, account, control->generation,
choice.action_id, encode_cellular_mutation_input(choice), 5s);
CHECK(reservation);
CellularBatch mutation;
mutation.header = header(1);
mutation.ticks.push_back({{{life_id, {}}},
{},
{{life_id, choice.input.event_index, choice.input.offer_tick,
reservation->successor_identity, choice.input.operator_id}}});
auto candidate = replay_cellular_batch(*host->state(), mutation);
CHECK(candidate);
auto mutation_objects =
FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(mutation_objects);
const std::array choices{choice};
// Publishing without the mutation block is refused: only the block binds the choice.
CHECK(!publish_cellular_batch(*runtime, **mutation_objects, authority,
checked_value(host->committed()), mutation, **candidate,
distinct_commit(0x9B), build, 5s));
const auto published = publish_cellular_batch(
*runtime, **mutation_objects, authority, checked_value(host->committed()), mutation,
**candidate, distinct_commit(0x9B), build, 5s, {}, {}, choices);
CHECK(published && published->mutation_results.size() == 1);
const auto result = published->mutation_results.front();
// Applied exactly when the replayed life now carries the reserved successor genome.
const bool applied =
(*candidate)->lives().front().identity.genome == reservation->successor_identity;
CHECK(result == (applied ? CellularMutationResult::applied
: CellularMutationResult::insufficient_funding));
auto recovery_objects =
FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(recovery_objects);
const std::array<Sha256Digest, 1> retained{build};
auto recovered =
recover_cellular_checkpoint(*runtime, **recovery_objects, key, authority, retained, 5s);
CHECK(recovered && recovered->mutation_actions == std::vector{choice} &&
recovered->mutation_results == std::vector{result} &&
recovered->state->snapshot() == (*candidate)->snapshot());
host->drain();
host.reset();
auto restarted_objects =
FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(restarted_objects);
auto restarted_made =
CellularRegionHost::create(config(), connect, std::move(*restarted_objects));
CHECK(restarted_made);
auto restarted = std::move(*restarted_made);
CHECK(restarted->step().ready && restarted->state()->snapshot() == (*candidate)->snapshot());
restarted->drain();
}
// ADR-0121 11.4c-2: the host admits an exact choice of the outstanding offer, reserves it for
// the next tick, keeps it across a restart, refuses a checkpoint that skips it, publishes it
// with that tick and answers a repeat with the final outcome.
void cellular_host_admits_mutation_choices() {
using namespace evo::biology;
constexpr RegionKey key{9765, 1};
auto owner = connect_as(env("PGUSER"));
auto runtime = connect_as(env("EVO_PG_RUNTIME_USER"));
const auto build = filled<32>(0xDA);
CHECK(owner->query("INSERT INTO evolution.retained_builds(build_identity) VALUES "
"(decode(repeat('da',32),'hex')) ON CONFLICT DO NOTHING",
{}, 5s));
auto endowed = primitive_endowment();
CHECK(endowed);
auto funding = endowed->body;
funding.energy.value = endowed->reserve.energy.value + endowed->construction.value;
auto primitive = PrimitiveLives::create({key.world, key.region, 1, 17, funding, {{0, 0}}});
CHECK(primitive);
constexpr std::uint64_t stock = 100'000'000;
auto habitat = CellularHabitat::create(
{key.world,
key.region,
1,
1'000,
1'000,
{{{0, 0}, 29, {{stock}, {{{stock}, {stock}, {stock}, {stock}}}}}}});
CHECK(habitat);
auto opening =
CellularLives::create(**primitive, std::move(*habitat), {{1'000, 1'000}, 0, 293'150},
CellularLivesProfile::engulf);
CHECK(opening);
auto objects = FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(objects);
CHECK(provision_cellular_region(*owner, **objects, key, 1, **opening, distinct_commit(0x9C),
build, 5s));
CHECK(owner->query("INSERT INTO evolution.life_allocators VALUES(9765,1000) "
"ON CONFLICT DO NOTHING",
{}, 5s));
const auto connect = [&]() -> std::expected<std::unique_ptr<Postgres>, PgFailure> {
return Postgres::connect({env("PGHOST"),
{},
env("PGPORT"),
env("PGDATABASE"),
env("EVO_PG_RUNTIME_USER"),
{},
{}},
5s);
};
// A fresh value per host: copying the config trips a GCC 14 -O3 array-bounds false positive.
const auto config = [&] { return CellularHostConfig{key, 1, {}, build, {build}}; };
auto made = CellularRegionHost::create(config(), connect, std::move(*objects));
CHECK(made);
auto host = std::move(*made);
CHECK(host->step().ready);
const auto account = filled<16>(0x74);
const auto control = claim_account_control(*runtime, key, checked_value(host->authority()),
account, 1, 1, 60'000ms, 5s);
CHECK(control);
CHECK(host->create_primitive_life(account, control->generation, 11).result ==
evo::network::PrimitiveLifeResult::pending);
const auto header = [&](const CellularRegionHost& at, std::uint64_t ticks) {
const auto& committed = checked_value(at.committed());
const auto digest = sha256(committed.manifest);
CHECK(digest);
return CellularBatchHeader{key.world,
key.region,
1,
committed.head.commit,
checked_value(digest),
at.state()->tick(),
at.state()->tick() + ticks};
};
CellularBatch birth;
birth.header = header(*host, 1);
birth.ticks.push_back({{}, {host->queued_births().front()}, {}});
CHECK(host->publish(birth));
const auto life_id = host->state()->lives().front().identity.life;
for (int round = 0; round < 4 && !host->state()->lives().front().mutation.offer; ++round) {
CHECK(host->step().ready);
CellularBatch feeding;
feeding.header = header(*host, 64);
CellularStepIntent feed{};
feed.intake_target = CellularPatchAddress{0, 0};
for (int tick = 0; tick < 64; ++tick)
feeding.ticks.push_back({{{life_id, feed}}, {}, {}});
CHECK(host->publish(feeding));
}
const auto& life = host->state()->lives().front();
const auto offer = checked_value(life.mutation.offer);
const CellularMutationActionInput choice{life_id, life.mutation.event_index,
life.mutation.offer_tick,
offer.candidates.front().operator_id};
const auto next = host->state()->tick() + 1;
// 11.4d: the owner's view lists the same candidates in operator order.
const auto view = offer_view(life, next - 1);
CHECK(view.life_identity == life_id && view.event_index == choice.event_index &&
view.offer_tick == choice.offer_tick &&
view.candidates.size() == offer.candidates.size() &&
std::ranges::is_sorted(view.candidates, {},
&evo::network::CellularOfferedCandidate::operator_id));
auto wrong = choice;
wrong.operator_id = 0xFFFF;
CHECK(host->select_mutation(account, control->generation, 31, wrong).status ==
CellularMutationAdmission::invalid);
auto stale = choice;
++stale.event_index;
CHECK(host->select_mutation(account, control->generation, 31, stale).status ==
CellularMutationAdmission::invalid);
const auto admitted = host->select_mutation(account, control->generation, 31, choice);
CHECK(admitted.status == CellularMutationAdmission::admitted && admitted.tick == next);
const auto repeated = host->select_mutation(account, control->generation, 31, choice);
CHECK(repeated.status == CellularMutationAdmission::admitted && repeated.tick == next);
CHECK(host->select_mutation(account, control->generation, 32, choice).status ==
CellularMutationAdmission::busy);
CHECK(host->queued_mutations().size() == 1);
const auto reservation = host->queued_mutations().front();
// A restarted host reloads the reserved choice for the same next tick.
host->drain();
host.reset();
auto reopened = FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(reopened);
auto restarted_made = CellularRegionHost::create(config(), connect, std::move(*reopened));
CHECK(restarted_made);
host = std::move(*restarted_made);
CHECK(host->step().ready && host->state()->tick() + 1 == next);
CHECK(host->queued_mutations().size() == 1 && host->queued_mutations().front() == reservation);
// A checkpoint for that tick without the choice is refused; the queue survives it.
CellularBatch skipped;
skipped.header = header(*host, 1);
skipped.ticks.push_back({{{life_id, {}}}, {}, {}});
CHECK(!host->publish(skipped));
CHECK(host->step().ready && host->queued_mutations().size() == 1);
CellularBatch chosen;
chosen.header = header(*host, 1);
chosen.ticks.push_back({{{life_id, {}}},
{},
{{life_id, choice.event_index, choice.offer_tick,
reservation.successor_identity, choice.operator_id}}});
const std::array records{CellularMutationActionRecord{account, 31, next, choice}};
const auto published = host->publish(chosen, {}, records);
CHECK(published && published->mutation_results.size() == 1);
CHECK(host->queued_mutations().empty());
const auto finalized = host->take_finalized_mutations();
CHECK(finalized.size() == 1 && finalized.front().account == account &&
finalized.front().action_id == 31 && finalized.front().tick == next &&
finalized.front().result == published->mutation_results.front() &&
finalized.front().commit_sequence == published->committed.head.sequence);
const auto outcome = action_outcome(finalized.front());
CHECK(outcome.action_id == 31 && outcome.tick == next &&
outcome.result == (finalized.front().result == CellularMutationResult::applied
? evo::network::ActionResult::committed
: evo::network::ActionResult::committed_no_effect));
// A repeat after publication answers with the same final outcome.
const auto final_repeat = host->select_mutation(account, control->generation, 31, choice);
CHECK(final_repeat.status == CellularMutationAdmission::final && final_repeat.outcome &&
*final_repeat.outcome == finalized.front());
CHECK(admit_status(final_repeat.status) == evo::network::AdmitStatus::duplicate);
host->drain();
}
// ADR-0125 (schema v36): a rules-4 region publishes a bud with its tick; the wildlife
// descendant, its identity and the parent's debit recover after a restart.
void cellular_bud_publishes_and_recovers() {
using namespace evo::biology;
constexpr RegionKey key{9767, 1};
auto owner = connect_as(env("PGUSER"));
auto runtime = connect_as(env("EVO_PG_RUNTIME_USER"));
const auto build = filled<32>(0xDB);
CHECK(owner->query("INSERT INTO evolution.retained_builds(build_identity) VALUES "
"(decode(repeat('db',32),'hex')) ON CONFLICT DO NOTHING",
{}, 5s));
auto endowed = primitive_endowment();
CHECK(endowed);
auto funding = endowed->body;
funding.energy.value = endowed->reserve.energy.value + endowed->construction.value;
auto primitive = PrimitiveLives::create({key.world, key.region, 1, 17, funding, {{0, 0}}});
CHECK(primitive);
constexpr std::uint64_t stock = 10'000'000'000;
auto habitat = CellularHabitat::create(
{key.world,
key.region,
1,
3'000,
2'000,
{{{0, 0}, 29, {{stock}, {{{stock}, {stock}, {stock}, {stock}}}}}}});
CHECK(habitat);
auto opening =
CellularLives::create(**primitive, std::move(*habitat), {{3'000, 2'000}, 0, 293'150},
CellularLivesProfile::budding);
CHECK(opening);
auto objects = FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(objects);
CHECK(provision_cellular_region(*owner, **objects, key, 1, **opening, distinct_commit(0x9D),
build, 5s));
CHECK(owner->query("INSERT INTO evolution.life_allocators VALUES(9767,1000) "
"ON CONFLICT DO NOTHING",
{}, 5s));
const auto connect = [&]() -> std::expected<std::unique_ptr<Postgres>, PgFailure> {
return Postgres::connect({env("PGHOST"),
{},
env("PGPORT"),
env("PGDATABASE"),
env("EVO_PG_RUNTIME_USER"),
{},
{}},
5s);
};
// A fresh value per host: copying the config trips a GCC 14 -O3 array-bounds false positive.
const auto config = [&] { return CellularHostConfig{key, 1, {}, build, {build}}; };
auto made = CellularRegionHost::create(config(), connect, std::move(*objects));
CHECK(made);
auto host = std::move(*made);
CHECK(host->step().ready);
const auto account = filled<16>(0x84);
const auto control = claim_account_control(*runtime, key, checked_value(host->authority()),
account, 1, 1, 60'000ms, 5s);
CHECK(control);
CHECK(host->create_primitive_life(account, control->generation, 11).result ==
evo::network::PrimitiveLifeResult::pending);
const auto header = [&](std::uint64_t ticks) {
const auto& committed = checked_value(host->committed());
const auto digest = sha256(committed.manifest);
CHECK(digest);
return CellularBatchHeader{key.world,
key.region,
1,
committed.head.commit,
checked_value(digest),
host->state()->tick(),
host->state()->tick() + ticks};
};
CellularBatch birth;
birth.header = header(1);
birth.ticks.push_back({{}, {host->queued_births().front()}, {}});
CHECK(host->publish(birth));
const auto parent = host->state()->lives().front().identity.life;
CellularStepIntent feed{};
feed.intake_target = CellularPatchAddress{0, 0};
CellularStepIntent bud{};
bud.bud = true;
// Feed for 63 ticks, then ask to bud on the batch's last tick, until it buds.
for (int round = 0; round < 200 && host->state()->lives().size() == 1; ++round) {
CHECK(host->step().ready);
CellularBatch batch;
batch.header = header(64);
for (int tick = 0; tick < 63; ++tick)
batch.ticks.push_back({{{parent, feed}}, {}, {}});
batch.ticks.push_back({{{parent, bud}}, {}, {}});
CHECK(host->publish(batch));
}
CHECK(host->state()->lives().size() == 2);
const auto expected_bud = cellular_bud_identity(key.region, 1);
const auto& wildlife = host->state()->lives()[1];
CHECK(wildlife.identity.life == expected_bud && wildlife.parent_life == parent &&
wildlife.account == LifeAccount{} && host->state()->next_bud_sequence() == 2);
const auto snapshot = host->state()->snapshot();
host->drain();
host.reset();
auto reopened = FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(reopened);
auto restarted = CellularRegionHost::create(config(), connect, std::move(*reopened));
CHECK(restarted);
CHECK((*restarted)->step().ready && (*restarted)->state()->snapshot() == snapshot);
(*restarted)->drain();
}
// ADR-0127 (schema v37): a dead life stays dead, its corpse stays, and its account starts
// a new primitive life with a new identity; the first life's history is unchanged.
void cellular_death_is_final_and_account_restarts() {
using namespace evo::biology;
constexpr RegionKey key{9768, 1};
auto owner = connect_as(env("PGUSER"));
auto runtime = connect_as(env("EVO_PG_RUNTIME_USER"));
const auto build = filled<32>(0xDC);
CHECK(owner->query("INSERT INTO evolution.retained_builds(build_identity) VALUES "
"(decode(repeat('dc',32),'hex')) ON CONFLICT DO NOTHING",
{}, 5s));
auto endowed = primitive_endowment();
CHECK(endowed);
auto funding = endowed->body;
funding.energy.value = endowed->reserve.energy.value + endowed->construction.value;
funding.energy.value *= 2;
for (auto& channel : funding.matter)
channel.value *= 2;
auto primitive =
PrimitiveLives::create({key.world, key.region, 1, 17, funding, {{0, 0}, {2'000, 0}}});
CHECK(primitive);
auto habitat = CellularHabitat::create({key.world, key.region, 1, 3'000, 2'000, {}});
CHECK(habitat);
auto opening =
CellularLives::create(**primitive, std::move(*habitat), {{3'000, 2'000}, 0, 293'150},
CellularLivesProfile::engulf);
CHECK(opening);
auto objects = FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(objects);
CHECK(provision_cellular_region(*owner, **objects, key, 1, **opening, distinct_commit(0x9E),
build, 5s));
CHECK(owner->query("INSERT INTO evolution.life_allocators VALUES(9768,1000) "
"ON CONFLICT DO NOTHING",
{}, 5s));
const auto connect = [&]() -> std::expected<std::unique_ptr<Postgres>, PgFailure> {
return Postgres::connect({env("PGHOST"),
{},
env("PGPORT"),
env("PGDATABASE"),
env("EVO_PG_RUNTIME_USER"),
{},
{}},
5s);
};
// A fresh value per host: copying the config trips a GCC 14 -O3 array-bounds false positive.
const auto config = [&] { return CellularHostConfig{key, 1, {}, build, {build}}; };
auto made = CellularRegionHost::create(config(), connect, std::move(*objects));
CHECK(made);
auto host = std::move(*made);
CHECK(host->step().ready);
const auto account = filled<16>(0x94);
const auto control = claim_account_control(*runtime, key, checked_value(host->authority()),
account, 1, 1, 60'000ms, 5s);
CHECK(control);
const auto header = [&](std::uint64_t ticks) {
const auto& committed = checked_value(host->committed());
const auto digest = sha256(committed.manifest);
CHECK(digest);
return CellularBatchHeader{key.world,
key.region,
1,
committed.head.commit,
checked_value(digest),
host->state()->tick(),
host->state()->tick() + ticks};
};
const auto born = [&](std::uint64_t request) {
CHECK(host->create_primitive_life(account, control->generation, request).result ==
evo::network::PrimitiveLifeResult::pending);
CellularBatch birth;
birth.header = header(1);
std::vector<CellularLifeIntent> idle;
for (const auto& life : host->state()->lives())
idle.push_back({life.identity.life, {}});
birth.ticks.push_back({idle, {host->queued_births().front()}, {}});
CHECK(host->publish(birth));
const auto outcome = host->query_primitive_life(account, control->generation, request);
CHECK(outcome.result == evo::network::PrimitiveLifeResult::born);
return outcome.life_identity;
};
const auto first = born(11);
// Unfed in an empty habitat, the founder starves. A batch that runs past the death
// names a dead life and is refused by replay, so near the end publish single ticks.
for (int round = 0; round < 4'000 && !host->state()->lives().empty(); ++round) {
CHECK(host->step().ready);
const auto idle = [&](std::uint64_t ticks) {
CellularBatch batch;
batch.header = header(ticks);
for (std::uint64_t tick = 0; tick < ticks; ++tick)
batch.ticks.push_back({{{first, {}}}, {}, {}});
return batch;
};
if (!host->publish(idle(32)))
CHECK(host->publish(idle(1)));
}
CHECK(host->state()->lives().empty() && host->state()->corpses().size() == 1 &&
host->state()->corpses().front().life_id == first);
CHECK(host->step().ready); // Records any ending a failed flush left behind.
const auto owner_region =
primitive_life_owner(*runtime, key, checked_value(host->authority()), account, 5s);
CHECK(owner_region && !*owner_region); // No active life anywhere.
// The same account starts a new primitive life; the first one is history.
const auto second = born(12);
CHECK(second != first && host->state()->lives().size() == 1 &&
host->state()->lives().front().identity.life == second &&
host->state()->corpses().size() == 1);
CHECK(host->query_primitive_life(account, control->generation, 11).result ==
evo::network::PrimitiveLifeResult::born);
// While the second life lives, a third request is an existing-life refusal.
CHECK(host->create_primitive_life(account, control->generation, 13).result ==
evo::network::PrimitiveLifeResult::existing_life);
const auto snapshot = host->state()->snapshot();
host->drain();
host.reset();
auto reopened = FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(reopened);
auto restarted = CellularRegionHost::create(config(), connect, std::move(*reopened));
CHECK(restarted);
CHECK((*restarted)->step().ready && (*restarted)->state()->snapshot() == snapshot);
(*restarted)->drain();
}
} // namespace
void run_cellular_publication_tests() {
cellular_birth_publication_is_durable();
cellular_profile_migration_is_durable_and_recovers_without_a_tick();
cellular_mutation_publication_binds_results();
cellular_host_admits_mutation_choices();
cellular_bud_publishes_and_recovers();
cellular_death_is_final_and_account_restarts();
auto owner = connect_as(env("PGUSER"));
const auto build = filled<32>(0xD9);
CHECK(owner->query("INSERT INTO evolution.retained_builds(build_identity) VALUES "
"(decode(repeat('d9',32),'hex')) ON CONFLICT DO NOTHING",
{}, 5s));
constexpr RegionKey empty_key{9757, 1};
auto empty_nursery =
PrimitiveLives::create({empty_key.world, empty_key.region, 1, 17, {}, {{0, 0}}});
CHECK(empty_nursery);
auto empty_habitat = evo::biology::CellularHabitat::create(
{empty_key.world,
empty_key.region,
1,
1'000,
1'000,
{{{0, 0}, 19, {{12'000}, {{{10}, {20}, {30}, {40}}}}}}});
CHECK(empty_habitat);
auto empty_opening = CellularLives::create(**empty_nursery, std::move(*empty_habitat),
{{1'000, 1'000}, 0, 293'150});
CHECK(empty_opening && (*empty_opening)->lives().empty());
auto empty_objects =
FilesystemObjectStore::open(env("PGHOST"), empty_key, max_cellular_lives_bytes);
CHECK(empty_objects);
const auto empty_commit = filled<16>(0x20);
auto provisioned = provision_cellular_region(*owner, **empty_objects, empty_key, 1,
**empty_opening, empty_commit, build, 5s);
CHECK(provisioned && provisioned->head.sequence == 0 && provisioned->head.end_tick == 0);
auto empty_manifest = decode_manifest(provisioned->manifest);
CHECK(empty_manifest && empty_manifest->profile == CheckpointProfile::cellular_lives_v1 &&
empty_manifest->cellular_versions == cellular_v2_versions &&
empty_manifest->payload_bytes == (*empty_opening)->snapshot().size());
auto genesis_payload =
(*empty_objects)->get({empty_manifest->payload_sha256, empty_manifest->payload_bytes});
CHECK(genesis_payload);
auto restored_genesis = restore_cellular_payload(*genesis_payload, *empty_manifest);
CHECK(restored_genesis && (*restored_genesis)->lives().empty() &&
(*restored_genesis)->nursery() == (*empty_opening)->nursery() &&
(*restored_genesis)->habitat().snapshot() == (*empty_opening)->habitat().snapshot());
auto exact_retry = provision_cellular_region(*owner, **empty_objects, empty_key, 1,
**empty_opening, empty_commit, build, 5s);
CHECK(exact_retry && exact_retry->manifest == provisioned->manifest);
CHECK(!provision_cellular_region(*owner, **empty_objects, empty_key, 1, **empty_opening,
filled<16>(0x22), build, 5s));
constexpr RegionKey key{9756, 1};
auto endowment = evo::biology::primitive_endowment();
CHECK(endowment);
auto funding = endowment->body;
funding.energy.value = endowment->reserve.energy.value + endowment->construction.value;
auto primitive = PrimitiveLives::create({key.world, key.region, 1, 17, funding, {{0, 0}}});
CHECK(primitive);
auto habitat =
evo::biology::CellularHabitat::create({key.world, key.region, 1, 1'000, 1'000, {}});
CHECK(habitat);
auto opening =
CellularLives::create(**primitive, std::move(*habitat), {{1'000, 1'000}, 0, 293'150});
CHECK(opening && (*opening)->lives().empty());
const auto payload = (*opening)->snapshot();
const auto payload_digest = sha256(payload);
CHECK(payload_digest);
auto genesis = genesis_manifest(key, 1, filled<16>(0x21), 50'000, build, payload.size(),
*payload_digest, CheckpointProfile::cellular_lives_v1);
CHECK(genesis);
genesis->cellular_versions = cellular_v2_versions;
const auto genesis_bytes = encode_manifest(*genesis);
CHECK(genesis_bytes);
auto objects = FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(objects && (*objects)->put(payload));
CHECK(owner->query("SELECT evolution.provision_region_checkpoint($1::bytea)",
std::array{hex(*genesis_bytes)}, 5s));
CHECK(owner->query("INSERT INTO evolution.life_allocators VALUES(9756,1000) "
"ON CONFLICT DO NOTHING",
{}, 5s));
const auto connect = [&]() -> std::expected<std::unique_ptr<Postgres>, PgFailure> {
return Postgres::connect({env("PGHOST"),
{},
env("PGPORT"),
env("PGDATABASE"),
env("EVO_PG_RUNTIME_USER"),
{},
{}},
5s);
};
// A fresh value per host: copying the config trips a GCC 14 -O3 array-bounds false positive.
const auto config = [&] { return CellularHostConfig{key, 1, {}, build, {build}}; };
auto made_host = CellularRegionHost::create(config(), connect, std::move(*objects));
CHECK(made_host);
auto host = std::move(*made_host);
CHECK(host->step().ready);
const auto authority = host->authority();
CHECK(authority);
auto runtime = connect_as(env("EVO_PG_RUNTIME_USER"));
const auto account = filled<16>(0x43);
const auto control =
claim_account_control(*runtime, key, checked_value(authority), account, 1, 1, 20'000ms, 5s);
CHECK(control);
const auto requested = host->create_primitive_life(account, control->generation, 7);
CHECK(requested.result == evo::network::PrimitiveLifeResult::pending &&
requested.life_identity != 0 && host->queued_births().size() == 1);
const auto committed = host->committed();
CHECK(committed);
const auto& committed_value = checked_value(committed);
CellularBatch batch;
const auto predecessor_digest = sha256(committed_value.manifest);
CHECK(predecessor_digest);
batch.header = {
key.world, key.region, 1, committed_value.head.commit, checked_value(predecessor_digest),
0, 1};
batch.ticks.resize(1);
batch.ticks.front().births.push_back(host->queued_births().front());
const auto birth_replay = replay_cellular_batch(*host->state(), batch);
CHECK(birth_replay);
const auto birth_publication = host->publish(batch);
CHECK(birth_publication && birth_publication->committed.head.sequence == 1 &&
birth_publication->committed.head.end_tick == 1 &&
host->state()->snapshot() == (**birth_replay).snapshot());
const auto action_predecessor = host->committed();
CHECK(action_predecessor);
const auto& action_predecessor_value = checked_value(action_predecessor);
const auto action_predecessor_digest = sha256(action_predecessor_value.manifest);
CHECK(action_predecessor_digest);
batch = {};
batch.header = {key.world,
key.region,
1,
action_predecessor_value.head.commit,
checked_value(action_predecessor_digest),
1,
2};
batch.ticks.resize(1);
batch.ticks.front().lives.push_back({requested.life_identity, {}});
CellularActionRecord action;
action.account = account;
action.action_id = 77;
action.input[0] = 2; // Tick 2, neutral movement, no patch target.
const std::array actions{action};
const auto replay = replay_cellular_batch(*host->state(), batch);
CHECK(replay);
auto published = host->publish(batch, actions);
CHECK(published && published->committed.head.sequence == 2 &&
published->committed.head.end_tick == 2 &&
host->state()->snapshot() == (**replay).snapshot());
CHECK(host->take_finalized_actions() == std::vector<FinalCellularAction>{{action, 2}});
host->drain();
host.reset();
auto restarted_objects =
FilesystemObjectStore::open(env("PGHOST"), key, max_cellular_lives_bytes);
CHECK(restarted_objects);
auto made_restarted =
CellularRegionHost::create(config(), connect, std::move(*restarted_objects));
CHECK(made_restarted);
auto restarted = std::move(*made_restarted);
CHECK(restarted->step().ready);
const auto restarted_committed = restarted->committed();
CHECK(restarted_committed);
const auto& restarted_committed_value = checked_value(restarted_committed);
CHECK(restarted->state()->tick() == 2 &&
restarted->state()->snapshot() == (**replay).snapshot() &&
restarted_committed_value.head.sequence == 2);
restarted->drain();
}