#pragma once #include "evo/server/lifecycle/cellular_lives.hpp" #include #include #include #include #include #include #include #include namespace evo::server { struct CellularBatchHeader { std::uint64_t world{}, region{}, frame{}; std::array predecessor{}; std::array predecessor_digest{}; std::uint64_t begin_tick{}, end_tick{}; friend bool operator==(const CellularBatchHeader&, const CellularBatchHeader&) = default; }; inline constexpr std::uint32_t cellular_batch_format = 3; inline constexpr std::uint32_t cellular_batch_v2_format = 2; inline constexpr std::uint32_t cellular_batch_legacy_format = 1; struct CellularTickIntents { // One intention for each life alive at the start of this tick, sorted by life_id. std::vector lives; // Owner-authorized births are sorted by (account, request). Biology and // placement are derived during replay after the existing-life step. struct Birth { LifeAccount account{}; std::uint64_t request{}, generation{}, identity{}; friend bool operator==(const Birth&, const Birth&) = default; }; std::vector births; // Choices accepted against the preceding checkpoint and scheduled for this tick. // The successor identity is durably reserved before the batch is replayed. std::vector mutations; friend bool operator==(const CellularTickIntents&, const CellularTickIntents&) = default; }; // Transient scheduler report, not part of the replay trace. A refused birth changes // no biology; its final request result is recorded in the existing reservation store. struct CellularBirthRefusal { CellularTickIntents::Birth birth; CellularLivesError reason{}; }; struct CellularBatch { CellularBatchHeader header{}; std::vector ticks; std::uint32_t format_version{cellular_batch_format}; friend bool operator==(const CellularBatch&, const CellularBatch&) = default; }; struct CellularActionRecord { std::array account{}; std::uint64_t action_id{}; std::array input{}; friend bool operator==(const CellularActionRecord&, const CellularActionRecord&) = default; }; struct CellularMutationActionInput { std::uint64_t life_id{}, event_index{}, offer_tick{}; std::uint16_t operator_id{}; friend bool operator==(const CellularMutationActionInput&, const CellularMutationActionInput&) = default; }; struct CellularMutationActionRecord { std::array account{}; std::uint64_t action_id{}, tick{}; CellularMutationActionInput input{}; friend bool operator==(const CellularMutationActionRecord&, const CellularMutationActionRecord&) = default; }; inline constexpr std::size_t cellular_batch_header_bytes = 112; inline constexpr std::size_t cellular_batch_v1_tick_header_bytes = 4; inline constexpr std::size_t cellular_batch_v2_tick_header_bytes = 8; inline constexpr std::size_t cellular_batch_tick_header_bytes = 16; inline constexpr std::size_t cellular_batch_intent_bytes = 24; inline constexpr std::size_t cellular_batch_birth_bytes = 40; inline constexpr std::size_t cellular_batch_mutation_bytes = 40; inline constexpr std::size_t max_cellular_batch_ticks = 64; inline constexpr std::size_t max_cellular_batch_bytes = cellular_batch_header_bytes + max_cellular_batch_ticks * (cellular_batch_tick_header_bytes + biology::max_cellular_tick_lives * (cellular_batch_intent_bytes + cellular_batch_birth_bytes + cellular_batch_mutation_bytes)); enum class CellularBatchError : std::uint8_t { format, version, scope, state }; inline constexpr std::size_t cellular_action_record_bytes = 48; inline constexpr std::size_t max_cellular_action_records = 1'024; inline constexpr std::size_t cellular_mutation_action_record_bytes = 64; enum class CellularActionBlockError : std::uint8_t { format, mismatch }; // Canonical replay input: one bounded, life-ID-ordered intention set per tick. [[nodiscard]] std::expected, CellularBatchError> encode_cellular_batch(const CellularBatch& batch); [[nodiscard]] std::expected decode_cellular_batch(std::span bytes); // Replays from an immutable predecessor snapshot. The caller must first bind the // header identity, predecessor commit/digest and tick range to trusted manifests. // Every tick must cover its living set; the caller compares the returned snapshot. [[nodiscard]] std::expected, CellularBatchError> replay_cellular_batch(const CellularLives& base, const CellularBatch& batch); // The same replay, also reporting every mutation selection's final result in trace order // (ADR-0121): the authority for the results a publication binds and recovery compares. struct CellularMutationOutcome { std::uint64_t tick{}, life_id{}, successor_id{}; CellularMutationResult result{}; friend bool operator==(const CellularMutationOutcome&, const CellularMutationOutcome&) = default; }; [[nodiscard]] std::expected, CellularBatchError> replay_cellular_batch(const CellularLives& base, const CellularBatch& batch, std::vector& mutation_outcomes); // The canonical 34-byte reserved choice (schema v29): tick, life, event and offer tick as // u64 and the operator as u16, little-endian. inline constexpr std::size_t cellular_mutation_input_bytes = 34; [[nodiscard]] std::array encode_cellular_mutation_input(const CellularMutationActionRecord& action); [[nodiscard]] std::optional decode_cellular_mutation_input(const std::array& account, std::uint64_t action_id, std::span input); [[nodiscard]] std::expected, CellularActionBlockError> encode_cellular_action_block(std::span actions, std::uint64_t begin_tick, std::uint64_t end_tick); [[nodiscard]] std::expected, CellularActionBlockError> decode_cellular_action_block(std::span bytes, std::uint64_t begin_tick, std::uint64_t end_tick); [[nodiscard]] std::expected, CellularActionBlockError> encode_cellular_mutation_action_block(std::span actions, std::uint64_t begin_tick, std::uint64_t end_tick); [[nodiscard]] std::expected, CellularActionBlockError> decode_cellular_mutation_action_block(std::span bytes, std::uint64_t begin_tick, std::uint64_t end_tick); // Every durable action must match the canonical input for that account's life // in the corresponding replay tick. An action cannot create a life or intent. [[nodiscard]] std::expected match_cellular_actions_to_trace(const CellularLives& predecessor, const CellularBatch& batch, std::span actions); [[nodiscard]] std::expected match_cellular_mutation_actions_to_trace(const CellularLives& predecessor, const CellularBatch& batch, std::span actions); } // namespace evo::server