Files
dingoandClaude Opus 5.5 c183021fd5
Foundation / checks (checks) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 4s
Foundation / checks (client) (push) Successful in 4s
Foundation / checks (postgres) (push) Successful in 4s
Foundation / checks (network) (push) Successful in 5s
Foundation / checks (tsan) (push) Successful in 5s
Foundation / checks (deploy) (push) Successful in 4m27s
Foundation / postgres-tools (push) Successful in 33s
Foundation / server-image (push) Successful in 4m14s
Foundation / image (push) Successful in 4m41s
feat(biology): genome schema 7 traits, founder 6 and development 7
Phase 1 of the cellular revamp build plan (ADR-0179). Genome schema 7 carries
twenty 16-bit cellular traits after the movement arrangement: density, upkeep
efficiency, growth speed, collection per channel (E/C/N/P/O), burn efficiency
per matter channel, engulf capacity, kill absorption, litter, the body recipe
(C/N/P/O per thousand, summing to 1000) and adhesion. Its membrane is held in
nanometres so it can change in 5% steps of the founder's 1 um. The largest
record still fits the 256-byte bound.

Development 7 and founder 6 serve rules 13: density sets how large a body is
for its mass, the recipe sets the body's composition (intake keeps the founder
shares), upkeep is an essential share no trait reduces plus the rest over upkeep
efficiency (region-declared BodyTuning, trial 25%), the producer speed penalty
is dropped, and the reproduction value is the bud's share of the body with the
construction discount fixed at the founder's level. Founder 6 builds exactly
founder 5's cell. Earlier schemas and development versions are unchanged.

The development and metabolism test mains now print the failing line. Refreshes
the DEV session window.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-22 18:09:06 -04:00

527 lines
24 KiB
C++

#include "evo/biology/genome.hpp"
#include <algorithm>
#include <iostream>
#include <source_location>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
namespace {
using namespace evo::biology;
void check(bool condition, std::source_location location = std::source_location::current()) {
if (!condition) {
throw std::runtime_error("genome line " + std::to_string(location.line()));
}
}
#define CHECK(expression) check(static_cast<bool>(expression))
// The three schema-required capabilities, in canonical order.
std::vector<CapabilityRecord> minimal() {
return {{Capability::energy_conversion, 400, 0},
{Capability::membrane, 120, 0},
{Capability::target_size, 5'000, 0}};
}
GenomeDraft founder() {
return {7, 1, 1, {}, minimal()};
}
GenomeDraft descendant() {
auto draft = founder();
draft.id = 8;
draft.origin_event = 2;
draft.parents = {7};
return draft;
}
std::uint32_t bits(std::initializer_list<Capability> kinds) {
std::uint32_t mask{};
for (const auto kind : kinds) {
mask |= capability_bit(kind);
}
return mask;
}
void reject(const GenomeDraft& draft, GenomeError expected,
std::source_location location = std::source_location::current()) {
const auto result = Genome::create(draft);
check(!result && result.error() == expected, location);
}
void founders_and_ancestry() {
const auto first = Genome::create(founder());
CHECK(first);
CHECK(first->id() == 7 && first->origin_event() == 1);
CHECK(first->schema_version() == 1 && first->development_version() == 1);
CHECK(first->parents().empty()); // Zero parents identifies a documented founder.
CHECK(first->capabilities().size() == 3);
CHECK(first->carries(Capability::membrane) && !first->carries(Capability::movement));
CHECK(first->parameter(Capability::membrane) && *first->parameter(Capability::membrane) == 120);
const auto absent = first->parameter(Capability::movement);
CHECK(!absent && absent.error() == GenomeError::missing_capability);
const auto child = Genome::create(descendant());
CHECK(child);
CHECK(child->parents().size() == 1 && child->parents()[0] == 7);
// Identical capabilities from a different origin never share a digest.
CHECK(child->content_digest() != first->content_digest());
CHECK(*child != *first);
// A draft is unordered input; the stored record is canonical.
auto shuffled = founder();
std::ranges::reverse(shuffled.capabilities);
const auto same = Genome::create(shuffled);
CHECK(same && *same == *first && same->encode() == first->encode());
CHECK(std::ranges::is_sorted(same->capabilities(), {}, &CapabilityRecord::kind));
}
void ancestry_rules() {
auto draft = descendant();
draft.id = 0;
reject(draft, GenomeError::invalid_identity);
draft = descendant();
draft.origin_event = 0;
reject(draft, GenomeError::invalid_identity);
draft = descendant();
draft.development_version = 0;
reject(draft, GenomeError::unsupported_version);
draft = descendant();
draft.parents = {0};
reject(draft, GenomeError::invalid_ancestry);
draft = descendant();
draft.parents = {draft.id}; // A genome cannot descend from itself.
reject(draft, GenomeError::invalid_ancestry);
draft = descendant();
draft.parents = {7, 9}; // Reserved in the format, rejected by schema 1.
reject(draft, GenomeError::invalid_ancestry);
draft = descendant();
draft.parents = {7, 7, 7};
reject(draft, GenomeError::invalid_ancestry);
}
void capability_and_range_rules() {
auto draft = founder();
draft.capabilities.clear();
reject(draft, GenomeError::missing_capability);
for (const auto required :
{Capability::energy_conversion, Capability::membrane, Capability::target_size}) {
draft = founder();
std::erase_if(draft.capabilities,
[required](const auto& record) { return record.kind == required; });
reject(draft, GenomeError::missing_capability);
}
draft = founder();
draft.capabilities.push_back({Capability::membrane, 130, 0});
reject(draft, GenomeError::duplicate_capability);
draft = founder();
draft.capabilities.push_back({static_cast<Capability>(capability_count), 1, 0});
reject(draft, GenomeError::unknown_capability);
draft = founder();
draft.capabilities.push_back({Capability::thermal_tolerance, 1, 1U << capability_count});
reject(draft, GenomeError::unknown_capability);
// Every boundary of every declared range, from both sides, in each schema's own table.
for (const auto schema :
{genome_schema_v1, genome_schema_v2, genome_schema_v3, genome_schema_v5}) {
const auto& table = *capability_schema_for(schema);
const auto fresh = [&] {
auto d = founder();
d.schema_version = schema;
return d;
};
for (std::size_t index = 0; index < capability_count; ++index) {
const auto kind = static_cast<Capability>(index);
const auto& limits = table[index];
// An empty range (photosynthesis before schema 5) admits no value at all.
if (limits.maximum < limits.minimum) {
CHECK(kind == Capability::photosynthesis && schema != genome_schema_v5);
for (const auto value : {0U, 1U, 100U, 1000U}) {
draft = fresh();
draft.capabilities.push_back({kind, value, 0});
reject(draft, GenomeError::parameter_out_of_range);
}
continue;
}
for (const auto value : {limits.minimum, limits.maximum}) {
draft = fresh();
std::erase_if(draft.capabilities,
[kind](const auto& record) { return record.kind == kind; });
draft.capabilities.push_back({kind, value, limits.mandates});
const auto accepted = Genome::create(draft);
CHECK(accepted && *accepted->parameter(kind) == value);
}
if (limits.minimum > 0) {
draft = fresh();
std::erase_if(draft.capabilities,
[kind](const auto& record) { return record.kind == kind; });
draft.capabilities.push_back({kind, limits.minimum - 1, limits.mandates});
reject(draft, GenomeError::parameter_out_of_range);
}
draft = fresh();
std::erase_if(draft.capabilities,
[kind](const auto& record) { return record.kind == kind; });
draft.capabilities.push_back({kind, limits.maximum + 1, limits.mandates});
reject(draft, GenomeError::parameter_out_of_range);
}
}
}
void development_graph_rules() {
// Movement and ingestion mandate a membrane, which a founder already carries.
auto draft = founder();
draft.capabilities.push_back({Capability::movement, 250, 0});
draft.capabilities.push_back({Capability::ingestion, 90, 0});
CHECK(Genome::create(draft));
// A declared prerequisite naming a capability the genome does not carry.
draft = founder();
draft.capabilities.push_back(
{Capability::thermal_tolerance, 500, bits({Capability::movement})});
reject(draft, GenomeError::missing_prerequisite);
// In schema 1 every mandated capability is also required, so a mandated
// capability can only be absent when a required one already is. Removing
// membrane reports that, not the mandate.
draft = founder();
std::erase_if(draft.capabilities,
[](const auto& record) { return record.kind == Capability::membrane; });
draft.capabilities.push_back({Capability::movement, 250, 0});
reject(draft, GenomeError::missing_capability);
draft = founder();
draft.capabilities.push_back({Capability::reproduction, 300, 0});
CHECK(Genome::create(draft)); // Reproduction mandates energy conversion, which is present.
// Self, mutual and longer cycles in the declared graph.
draft = founder();
draft.capabilities[1].prerequisites = bits({Capability::membrane});
reject(draft, GenomeError::cyclic_development);
draft = founder();
draft.capabilities[0].prerequisites = bits({Capability::membrane});
draft.capabilities[1].prerequisites = bits({Capability::energy_conversion});
reject(draft, GenomeError::cyclic_development);
draft = founder();
draft.capabilities[0].prerequisites = bits({Capability::membrane});
draft.capabilities[1].prerequisites = bits({Capability::target_size});
draft.capabilities[2].prerequisites = bits({Capability::energy_conversion});
reject(draft, GenomeError::cyclic_development);
// The same three edges without the closing one are a valid ordering.
draft = founder();
draft.capabilities[0].prerequisites = bits({Capability::membrane});
draft.capabilities[1].prerequisites = bits({Capability::target_size});
CHECK(Genome::create(draft));
// A mandated edge can close a cycle a declared edge opened.
draft = founder();
draft.capabilities.push_back({Capability::movement, 250, 0});
draft.capabilities[1].prerequisites = bits({Capability::movement});
reject(draft, GenomeError::cyclic_development);
}
void canonical_encoding() {
auto draft = descendant();
draft.capabilities.push_back({Capability::movement, 250, bits({Capability::membrane})});
draft.capabilities.push_back({Capability::reproduction, 300, 0});
const auto genome = Genome::create(draft);
CHECK(genome);
const auto bytes = genome->encode();
CHECK(bytes.size() <= max_genome_bytes);
const auto restored = Genome::decode(bytes);
CHECK(restored && *restored == *genome);
CHECK(restored->encode() == bytes); // Re-encoding is byte-exact.
CHECK(restored->content_digest() == genome->content_digest());
CHECK(restored->parents().size() == 1 && restored->parents()[0] == 7);
// Truncation at every length, and trailing bytes, are rejected.
for (std::size_t length = 0; length < bytes.size(); ++length) {
CHECK(!Genome::decode(std::span{bytes}.first(length)));
}
auto extended = bytes;
extended.push_back(0);
const auto trailing = Genome::decode(extended);
CHECK(!trailing && trailing.error() == GenomeError::invalid_encoding);
std::vector<std::uint8_t> oversized(max_genome_bytes + 1, 0);
CHECK(!Genome::decode(oversized));
// Every single-byte corruption is caught by the checksum or a later check.
for (std::size_t index = 0; index < bytes.size(); ++index) {
auto damaged = bytes;
damaged[index] = static_cast<std::uint8_t>(damaged[index] ^ 0xffU);
CHECK(!Genome::decode(damaged));
}
auto wrong_magic = bytes;
wrong_magic[0] = 'X';
const auto rejected = Genome::decode(wrong_magic);
CHECK(!rejected && rejected.error() == GenomeError::invalid_encoding);
}
void encoded_record_rules() {
const auto genome = Genome::create(descendant());
CHECK(genome);
auto bytes = genome->encode();
const auto reseal = [](std::vector<std::uint8_t>& raw) {
std::uint64_t hash = 14695981039346656037ULL;
for (std::size_t index = 0; index + 8 < raw.size(); ++index) {
hash = (hash ^ raw[index]) * 1099511628211ULL;
}
for (std::size_t index = 0; index < 8; ++index) {
raw[raw.size() - 8 + index] = static_cast<std::uint8_t>((hash >> (8U * index)) & 0xffU);
}
};
// A rewritten record with a valid checksum still fails the digest check.
auto rewritten = bytes;
rewritten[16] = static_cast<std::uint8_t>(rewritten[16] + 1); // A different genome ID.
reseal(rewritten);
const auto tampered = Genome::decode(rewritten);
CHECK(!tampered && tampered.error() == GenomeError::digest_mismatch);
// An unsupported schema version fails closed before anything else is read.
auto future = bytes;
future[8] = static_cast<std::uint8_t>(genome_schema_version + 1);
reseal(future);
const auto ahead = Genome::decode(future);
CHECK(!ahead && ahead.error() == GenomeError::unsupported_version);
// Non-canonical ordering is rejected even though both kinds are known.
auto unordered = Genome::create(founder())->encode();
const std::size_t first_record = 36 + 4;
const std::size_t second_record = first_record + 9;
std::swap_ranges(unordered.begin() + first_record, unordered.begin() + second_record,
unordered.begin() + second_record);
reseal(unordered);
const auto misordered = Genome::decode(unordered);
CHECK(!misordered && misordered.error() == GenomeError::duplicate_capability);
// A declared count larger than the schema knows about is refused. One parent
// sits between the fixed prefix and the capability count.
auto overcounted = bytes;
overcounted[36 + 8] = static_cast<std::uint8_t>(capability_count + 1);
reseal(overcounted);
const auto excessive = Genome::decode(overcounted);
CHECK(!excessive && excessive.error() == GenomeError::duplicate_capability);
// A parent count beyond the reserved room is refused before any parent is read.
auto crowded = bytes;
crowded[32] = static_cast<std::uint8_t>(max_parents + 1);
reseal(crowded);
const auto overfull = Genome::decode(crowded);
CHECK(!overfull && overfull.error() == GenomeError::invalid_ancestry);
}
// A frozen schema 1 record for the founder above, verified by hand against
// schemas/genome-v1.md. Changing these bytes changes the meaning of every
// existing v1 record: it needs a schema version and a migration, not an edit.
const std::vector<std::uint8_t>& frozen_founder() {
static const std::vector<std::uint8_t> bytes{
0x41, 0x45, 0x56, 0x4f, 0x47, 0x45, 0x4e, 0x31, // magic AEVOGEN1
0x01, 0x00, 0x00, 0x00, // schema version 1
0x01, 0x00, 0x00, 0x00, // development version 1
0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // genome ID 7
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // origin event 1
0x00, 0x00, 0x00, 0x00, // no parents: a founder
0x03, 0x00, 0x00, 0x00, // three capabilities
0x00, 0x90, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // conversion 400
0x01, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // membrane 120
0x05, 0x88, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // target size 5000
0x7f, 0xc8, 0x6a, 0xf1, 0xde, 0xde, 0x2c, 0x9b, // content digest
0x0b, 0xb0, 0xaa, 0xf8, 0x3c, 0x76, 0x83, 0xec}; // checksum
return bytes;
}
void frozen_record_compatibility() {
const auto genome = Genome::create(founder());
CHECK(genome);
// The encoder must still produce the bytes a v1 record was written with.
CHECK(genome->encode() == frozen_founder());
CHECK(frozen_founder().size() == 56 + 9 * 3);
CHECK(genome->content_digest() == 0x9b2cdedef16ac87fULL);
// The decoder must still read them, independently of what the encoder does.
const auto restored = Genome::decode(frozen_founder());
CHECK(restored);
CHECK(restored->id() == 7 && restored->origin_event() == 1);
CHECK(restored->schema_version() == 1 && restored->development_version() == 1);
CHECK(restored->parents().empty());
CHECK(restored->capabilities().size() == 3);
CHECK(restored->capabilities()[0] == (CapabilityRecord{Capability::energy_conversion, 400, 0}));
CHECK(restored->capabilities()[1] == (CapabilityRecord{Capability::membrane, 120, 0}));
CHECK(restored->capabilities()[2] == (CapabilityRecord{Capability::target_size, 5'000, 0}));
CHECK(restored->content_digest() == 0x9b2cdedef16ac87fULL);
CHECK(*restored == *genome);
}
// Schema 2 (ADR-0099): rates per second. Schema 1 records stay valid, unrewritten, and
// read as exactly twenty times their per-tick values.
void schema_v2_rates() {
auto v1 = founder();
v1.capabilities.push_back({Capability::movement, 5'000, 0});
v1.capabilities.push_back({Capability::ingestion, 1'000'000, 0}); // Schema 1 maximum.
const auto old = Genome::create(v1);
CHECK(old && old->schema_version() == genome_schema_v1);
CHECK(old->per_second(Capability::movement) == std::uint64_t{100'000});
CHECK(old->per_second(Capability::ingestion) == std::uint64_t{20'000'000});
CHECK(old->per_second(Capability::target_size) == std::uint64_t{5'000}); // Not a rate.
CHECK(!old->per_second(Capability::thermal_tolerance));
auto v2 = v1;
v2.schema_version = genome_schema_v2;
v2.capabilities[3].parameter = 100'000; // Movement, per second.
v2.capabilities[4].parameter = 20'000'000;
const auto now = Genome::create(v2);
CHECK(now && now->schema_version() == 2);
CHECK(now->per_second(Capability::movement) == old->per_second(Capability::movement));
CHECK(now->per_second(Capability::ingestion) == old->per_second(Capability::ingestion));
// The same meaning in another schema is another record.
CHECK(now->content_digest() != old->content_digest());
const auto restored = Genome::decode(now->encode());
CHECK(restored && *restored == *now && restored->schema_version() == 2);
// Ranges are per schema: a schema 2 rate may exceed schema 1's per-tick maximum.
v2.capabilities[4].parameter = 20'000'001;
reject(v2, GenomeError::parameter_out_of_range);
v1.capabilities[4].parameter = 1'000'001;
reject(v1, GenomeError::parameter_out_of_range);
auto unknown = founder();
unknown.schema_version = 8; // Schema 7 exists since rules 13.
reject(unknown, GenomeError::unsupported_version);
auto bytes = Genome::create(founder())->encode();
bytes[8] = 8; // Schema field; decode refuses before the checksum matters.
CHECK(!Genome::decode(bytes) &&
Genome::decode(bytes).error() == GenomeError::unsupported_version);
}
void moves_preserve_validity() {
const auto original = Genome::create(founder());
const auto other = Genome::create(descendant());
CHECK(original && other);
// Moves decay to copies, so a moved-from record is still a whole genome
// rather than an identity with no capabilities.
auto source = *original;
// The decay to a copy is the contract under test, so tidy is right that no
// move happens here and wrong that it is a mistake.
// NOLINTNEXTLINE(performance-move-const-arg)
const auto moved = std::move(source);
CHECK(moved == *original);
// NOLINTNEXTLINE(bugprone-use-after-move): the point of the check.
CHECK(source == *original);
CHECK(source.capabilities().size() == 3 && source.id() == 7);
CHECK(Genome::decode(source.encode()));
auto target = *original;
auto donor = *other;
// NOLINTNEXTLINE(performance-move-const-arg)
target = std::move(donor);
CHECK(target == *other);
// NOLINTNEXTLINE(bugprone-use-after-move): the point of the check.
CHECK(donor == *other);
CHECK(Genome::decode(donor.encode()));
static_assert(std::is_copy_constructible_v<Genome>);
static_assert(std::is_copy_assignable_v<Genome>);
}
// Schema 6 (rules 12): the movement arrangement is required, encoded after the capability
// records, covered by the digest, and refused before schema 6.
void schema_v6_movement_arrangement() {
auto draft = founder();
draft.schema_version = genome_schema_v6;
draft.development_version = 6;
reject(draft, GenomeError::parameter_out_of_range); // Missing arrangement.
draft.movement_arrangement = founder_movement_arrangement;
const auto genome = Genome::create(draft);
CHECK(genome && genome->movement_arrangement() == founder_movement_arrangement);
const auto bytes = genome->encode();
const auto decoded = Genome::decode(bytes);
CHECK(decoded && *decoded == *genome);
CHECK(bytes.size() == 36 + 4 + 3 * 9 + 18 + 16);
auto changed = draft;
changed.movement_arrangement->steering = 105;
const auto other = Genome::create(changed);
CHECK(other && other->content_digest() != genome->content_digest());
auto tampered = bytes;
tampered[36 + 4 + 3 * 9] ^= 1U; // First arrangement byte; the checksum catches it.
CHECK(!Genome::decode(tampered));
auto truncated = bytes;
truncated.erase(truncated.end() - 18, truncated.end() - 16);
CHECK(!Genome::decode(truncated));
for (auto bad : {MovementArrangement{1'001, 100, 0, 100, 100, 100, 0, 100, 0},
MovementArrangement{100, 0, 0, 100, 100, 100, 0, 100, 0},
MovementArrangement{100, 100, 0, 100, 100, 100, 0, 0, 0}}) {
auto refused = draft;
refused.movement_arrangement = bad;
reject(refused, GenomeError::parameter_out_of_range);
}
// Shed output and absent modules are valid.
auto shed = draft;
shed.movement_arrangement = MovementArrangement{0, 100, 0, 100, 100, 100, 0, 100, 0};
CHECK(Genome::create(shed));
auto early = founder();
early.schema_version = genome_schema_v5;
early.development_version = 5;
early.movement_arrangement = founder_movement_arrangement;
reject(early, GenomeError::parameter_out_of_range);
}
void schema_v7_cellular_traits() {
auto draft = founder();
draft.schema_version = genome_schema_v7;
draft.development_version = 7;
draft.movement_arrangement = founder_movement_arrangement;
reject(draft, GenomeError::parameter_out_of_range); // Missing traits.
draft.cellular_traits = founder_cellular_traits;
const auto genome = Genome::create(draft);
CHECK(genome && genome->cellular_traits() == founder_cellular_traits);
const auto bytes = genome->encode();
const auto decoded = Genome::decode(bytes);
CHECK(decoded && *decoded == *genome);
CHECK(bytes.size() == 36 + 4 + 3 * 9 + 18 + 40 + 16);
// The largest record still fits the bound: one parent and all eight capabilities.
CHECK(36 + 8 + 4 + 8 * 9 + 18 + 40 + 16 <= max_genome_bytes);
auto changed = draft;
changed.cellular_traits->litter = 25;
const auto other = Genome::create(changed);
CHECK(other && other->content_digest() != genome->content_digest());
CHECK(Genome::decode(other->encode()) == other);
auto tampered = bytes;
tampered[36 + 4 + 3 * 9 + 18] ^= 1U; // First trait byte; the checksum catches it.
CHECK(!Genome::decode(tampered));
auto truncated = bytes;
truncated.erase(truncated.end() - 18, truncated.end() - 16);
CHECK(!Genome::decode(truncated));
const auto refuse = [&](auto edit) {
auto refused = draft;
edit(*refused.cellular_traits);
reject(refused, GenomeError::parameter_out_of_range);
};
refuse([](CellularTraits& t) { t.density = 0; });
refuse([](CellularTraits& t) { t.upkeep_efficiency = 1'001; });
refuse([](CellularTraits& t) { t.collection[4] = 0; });
refuse([](CellularTraits& t) { t.burn[0] = 1'001; });
refuse([](CellularTraits& t) { t.litter = max_litter + 1; });
refuse([](CellularTraits& t) { t.adhesion = 2; });
refuse([](CellularTraits& t) { t.recipe = {500, 150, 50, 299}; }); // Sums to 999.
refuse([](CellularTraits& t) { t.recipe = {650, 300, 50, 0}; }); // A channel at zero.
auto shifted = draft;
shifted.cellular_traits->recipe = {480, 157, 57, 306}; // A thrifty-carbon body.
shifted.cellular_traits->adhesion = 1;
shifted.cellular_traits->litter = max_litter;
CHECK(Genome::create(shifted));
auto early = draft;
early.schema_version = genome_schema_v6;
early.development_version = 6;
reject(early, GenomeError::parameter_out_of_range); // Traits before schema 7.
// Schema 7 measures the membrane in nanometres: 10 mm is the bound, not 10 um.
auto thick = draft;
thick.capabilities[1].parameter = 10'000'000;
CHECK(Genome::create(thick));
thick.capabilities[1].parameter = 10'000'001;
reject(thick, GenomeError::parameter_out_of_range);
}
} // namespace
int main() try {
founders_and_ancestry();
ancestry_rules();
capability_and_range_rules();
development_graph_rules();
canonical_encoding();
encoded_record_rules();
frozen_record_compatibility();
schema_v2_rates();
moves_preserve_validity();
schema_v6_movement_arrangement();
schema_v7_cellular_traits();
std::cout << "PASS genome schema, ancestry, development graph and canonical encoding\n";
return 0;
} catch (const std::exception& e) {
std::cerr << e.what() << '\n';
return 1;
} catch (...) {
return 1;
}