Complete M6.2 optional finite environmental fields

This commit is contained in:
dingo
2026-09-27 00:21:05 -04:00
parent 750afcd4d4
commit ab130b0fbb
15 changed files with 984 additions and 3 deletions
+7 -1
View File
@@ -34,7 +34,7 @@ target_include_directories(evo_simulation PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/in
target_compile_features(evo_simulation PUBLIC cxx_std_23)
evo_owned_target(evo_simulation)
set(evo_world_sources src/world/coordinates.cpp src/world/generation.cpp src/world/chunks.cpp src/world/edits.cpp src/world/codec.cpp src/world/local_files.cpp src/world/environment_units.cpp)
set(evo_world_sources src/world/coordinates.cpp src/world/generation.cpp src/world/chunks.cpp src/world/edits.cpp src/world/codec.cpp src/world/local_files.cpp src/world/environment_units.cpp src/world/fields.cpp)
add_library(evo_world STATIC ${evo_world_sources})
add_library(evo::world ALIAS evo_world)
target_include_directories(evo_world PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include")
@@ -72,6 +72,12 @@ evo_owned_target(evo-sim)
include(CTest)
if(BUILD_TESTING)
add_executable(evo-world-fields-tests tests/world_fields_tests.cpp)
target_link_libraries(evo-world-fields-tests PRIVATE evo::world)
evo_owned_target(evo-world-fields-tests)
add_test(NAME world-fields-contracts COMMAND evo-world-fields-tests)
set_tests_properties(world-fields-contracts PROPERTIES TIMEOUT 60)
add_executable(evo-environment-units-tests tests/environment_units_tests.cpp)
target_link_libraries(evo-environment-units-tests PRIVATE evo::world evo::accounting)
evo_owned_target(evo-environment-units-tests)
+1
View File
@@ -28,6 +28,7 @@ network service. Dev verification manifests are separate from the simulation.
- [Local periodic spatial queries](docs/architecture/SPATIAL_CONTRACT.md)
- [Energy/matter model and implemented ledger boundary](docs/biology/ENERGY_MODEL.md)
- [Environmental units and habitat coupling](docs/world/ENVIRONMENTAL_UNITS.md)
- [Optional finite environmental fields and snapshot format](docs/world/ENVIRONMENTAL_FIELDS.md)
- [Genome model and implemented v1 record](docs/biology/GENOME_MODEL.md)
Read [AGENTS.md](AGENTS.md) before changing code. Architecture and contracts are
+5
View File
@@ -310,6 +310,11 @@ under ADR-0050. Pure checked habitat/ratio/energy-integration helpers and dimens
tests are implemented. No environmental stock, field codec, source scheduler or
terrain-to-biological-mass converter is implemented by this gate. Next: M6.2.
M6.2 implements [optional finite field storage](world/ENVIRONMENTAL_FIELDS.md),
material capacity defaults, bounded sparse pages, same-field local relocation and
canonical field snapshot v1 under ADR-0051. Rate-driven sources and combined
terrain/biology persistence are not provided by this independent codec. Next: M6.3.
## M7 - Persistent region server
**Goal:** a disposable authoritative headless process can recover a bounded region
+14 -2
View File
@@ -7,7 +7,7 @@ persistent simulation server. The founding vision remains unchanged.
## Completed implementation
- Vision, architectural pillars, risks, open-question register, architecture
diagrams, biological contracts, engineering constitution and 50 ADRs.
diagrams, biological contracts, engineering constitution and 51 ADRs.
Proposed/deferred choices remain distinct from accepted proof decisions.
- M0–M4 task breakdowns with dependencies, acceptance evidence and risks,
plus M5–M14 gates in [ROADMAP.md](ROADMAP.md).
@@ -61,7 +61,7 @@ for the bounded proof; the general production ECS remains a later measured choic
| Priority | Work | Completion evidence |
|---|---|---|
| 1 | M6.2 optional environmental fields | Finite versioned inventories, sparse field pages and round-trip persistence without regenerated supply |
| 1 | M6.3 read-only environment views | Footprint queries with explicit units, availability, tick and revision validity |
| Research | Improve aggregate fidelity and measure Linux/target-host costs | M4.6 found no qualifying width; see the aggregate budget report |
| 2 | Revisit the ADR-0031/0032 reproduction cost model | Reproduction is affordable only at the genome schema's floor; decide whether that is intended before M4 builds cohorts on it |
| Delivery gate | Add/update the dev workload when a deployable increment needs it; Argo is ready | Observe Job/pod completion separately from image publication; no World0 changes |
@@ -618,3 +618,15 @@ accounting and refusal rollback are tested. Windows Release, clang-tidy and ASan
suites pass; see VALIDATION.md for exact checks. Existing formats/goldens are unchanged.
No fields or biological coupling are implemented yet. Next: M6.2 optional finite
environmental fields with versioned persistence and explicit opening inventories.
## M6.2 optional finite environmental fields (2026-09-27)
Added a bounded FieldStore with fixed habitat mappings, material water-capacity
defaults, optional scalar channels and uniform baselines with sparse 64-site pages.
Opening inventories are explicit; missing differs from zero. Same-channel local
transfers preserve finite supply and reject stale commands/overspend without change.
Field snapshot v1 preserves mapping, quantities, defaults, presence and watermark;
restore does not regenerate supplies. [Contract and memory evidence](world/ENVIRONMENTAL_FIELDS.md)
and the byte schema document trust, budget and compatibility limits. M5 terrain
formats remain unchanged; combined terrain/biology durability and rate sources are
not implemented. Next: M6.3 read-only derived environment views.
@@ -0,0 +1,73 @@
# ADR-0051: Optional finite environmental field pages
## Status
Accepted for M6.2 bounded in-memory storage and binary-buffer persistence.
## Context
ADR-0050 defines units and one-voxel habitats. Terrain contains no extractable
nutrients. M6 needs finite stocks without allocating chemistry on every planet voxel.
The M5 codec cannot silently gain environmental state or promise atomic recovery of
independently saved geometry and biology.
## Decision
Add a separate `FieldStore` to evo::world. Creation fixes 1..4096 lexicographically
ordered habitat sites, one per voxel, each with an explicit local box and substrate
material ID. A nonzero opening ID records host provenance, not authentication.
World/frame, material defaults, mappings, field presence, quantities and command
watermark are serialized together. No site insertion, removal or regeneration API.
Three material water-capacity defaults (void/rock/regolith) are explicit nonnegative
fixture parameters. They supply no inventory or density. A site's substrate is a
field property, not a live terrain view; M6.4 must reconcile edits when binding stores.
Optional water, dissolved N/P, organic C/N/P/other/energy, incident energy and heat
channels own finite opening quantities. Missing differs from present zero. A field
opening supplies one uniform value or exactly one value per site; every repeated
uniform quantity is counted in global per-element/energy totals, checked against u64.
Compress each present channel with its first site's value as baseline, and allocate
64-value pages only where another site differs. Pages use stable site order, not
planet allocation. The bounded scalar layout is a scoped choice, not a claim of
optimal compression. Measure uniform and varying memory in tests.
Implement a same-channel, same-store transfer only: positive amount, distinct valid
sites, fresh nonzero action ID, sufficient balance, capacity and allocation budget.
Stage a replacement channel before atomic publication; success advances the persisted
watermark. Stale action IDs reject, including exact retries (ADR-0024 semantics).
There is no arbitrary setter, deletion, cross-compartment conversion or organism
credit. M6.4 still owns coordinated transactions and idempotent biological outcomes.
New field snapshot v1 uses canonical explicit little-endian logical values and an
FNV corruption checksum. Restore checks versions/identity/length/checksum and all
creation invariants into a detached store. It accepts no M5 snapshot as field state.
Host byte budgets exclude input/output buffers and allocator overhead; transient
channel replacement and bounded decode workspace are explicitly charged/documented.
Rate-driven sources are not supported: incident energy is only finite stock. Before
adding rates, persist rate identity, denominator, residual and interval watermark in
a new compatible format or explicit migration; never synthesize these on restore.
## Alternatives Considered
Dense chemistry per voxel violates sparse allocation goals. Derived material supply
would replenish after unloading. Piggybacking fields into M5 without a combined
transaction gives false durability. General adaptive grids and cross-store transfers
are unnecessary for the first storage contract. First-value baselines are simpler
than dictionaries, but an isolated change at site zero can allocate many pages.
## Benefits
Finite quantities, deterministic round trips, explicit absence and bounded sparse
allocation with no database or new dependency. Geometry formats remain unchanged.
## Costs
Logical wire arrays favor validation over compression. Fixed site membership caps
the proof; a changing baseline can increase replacement costs. Read access is scalar
by site/channel, not M6.3's tick/revision-tagged environment query.
## Risks
Host provenance and substrate declarations are trusted inputs. Restoring the same
snapshot twice does not fence process authority. Checksums do not authenticate data.
The snapshot is not automatically published by LocalWorldFiles or part of M5 recovery.
## Consequences
Document the byte schema and ownership boundary. Test absence/zero, uniform/varying
memory, exhaustion, rollback, global overflow, budgets, canonical continuation,
old/unknown versions and recomputed-checksum malformed inputs. Integrated persistent
region state remains M6.8/M7; no deployment or existing format/golden changes.
+1
View File
@@ -57,3 +57,4 @@ design. No unadopted candidate is a link dependency of the proof.
- [ADR-0048: Local publication](0048-local-publication.md) - accepted for M5.7 single-writer snapshot/journal publication and recovery.
- [ADR-0049: Bounded world proof](0049-bounded-world-proof.md) - accepted for M5.8 restart regression and cost evidence.
- [ADR-0050: Environmental units and coupling](0050-environmental-units-and-coupling.md) - accepted for M6's bounded habitat/accounting contract; no field storage or terrain conversion yet.
- [ADR-0051: Optional environmental fields](0051-optional-environmental-fields.md) - accepted for M6.2 finite sparse pages, local transfers and field snapshot v1.
+10
View File
@@ -163,3 +163,13 @@ derived concentrations/moisture, dimensional examples, closed/open accounting,
rate residual ownership and rejection of unsupported terrain mass conversions.
The implemented helpers are pure computations. Inventory pages, reservations,
ownership enforcement, transfer commits and persistence follow in M6.2-6.4.
## M6.2 optional field storage
[ADR-0051](../adr/0051-optional-environmental-fields.md) implements a separate
bounded [FieldStore](../world/ENVIRONMENTAL_FIELDS.md). It owns fixed habitat sites,
explicit finite inventories, property-only material defaults and optional uniform/
sparse scalar pages. Its versioned codec retains all field state and local transfer
watermark, without relying on procedural resource regeneration. M5 LocalWorldFiles
still publishes only terrain state: integrated terrain/fields/biology recovery must
use a later version bundle. No cross-store biological transfer is authorized here.
+6
View File
@@ -297,3 +297,9 @@ obligations of M6.2-6.7. Water is conserved `other` in a distinct compartment;
this does not authorize converting it into edible material or modeling reactions.
Bulk terrain-to-mass conversion remains unsupported pending density/composition
and an atomic representation transfer. No existing ledger or biological rules change.
M6.2 [optional fields](../world/ENVIRONMENTAL_FIELDS.md) now hold explicit water,
dissolved N/P, organic matter/energy, incident-energy and heat inventories. Material
defaults provide capacity, never supply. Local transfers can only relocate the same
channel; water cannot become organic other. Field snapshots preserve depletion.
No rate source, biochemical conversion or transfer to organisms exists yet.
+38
View File
@@ -1683,3 +1683,41 @@ Linux/UBSan and target-cluster checks were not executed locally; existing CI inc
the new CTest. There is no new concurrency requiring TSan work. Helpers do not enforce
owner identity, interval deduplication or residual persistence; those remain explicit
M6.2-6.7 obligations. No deployment or World0 operation occurred. Next: M6.2.
## M6.2 optional environmental fields - 2026-09-27
Added ADR-0051, FieldStore, field snapshot v1 and its byte schema. Optional water,
N/P, organic matter/energy, incident-energy and heat channels have explicit finite
openings. Material defaults specify water capacity only. Uniform baselines with
optional 64-site pages preserve absence versus zero. Same-channel local transfers
stage replacements before commit and persist a strictly increasing command watermark.
There is no resource setter, site regeneration, cross-compartment or organism credit.
Executed on Windows x64 / MSVC 19.44:
- `tools/windows-check.ps1 -Preset release -Action check`: 50/50 passed on final code.
- `tools/windows-check.ps1 -Preset analysis -Action check`: clang-tidy 19 and
50/50 passed on final code.
- `tools/windows-check.ps1 -Preset asan -Action check`: 50/50 passed on final code.
- `tools/windows-check.ps1 -Preset release -Action format`: passed.
- `git diff --check`: passed.
Initial build diagnostics corrected explicit aggregate initialization and bit widths.
The hostile fixed-underlying-type enum test has a narrowly scoped analyzer suppression
with rationale; actual channel validation remains exercised.
Tests cover uniform/sparse/varying memory, page seams and release, exhausted sources,
source/capacity/budget/stale-command rollback, absent/present-zero restore, cross-field
conserved-channel overflow, independent dense transfer continuation and all ten fields
at 4096 sites. Maximum logical snapshot is 630880 bytes. A separately constructed
170-byte absent-field fixture checks canonical schema bytes. Every truncation of a
260-byte fixture, invalid/old versions, identity, malformed/resealed mappings and
quantities, oversized snapshots and 256 repaired-checksum mutations are exercised.
Memory observations are in ENVIRONMENTAL_FIELDS.md; accounted bytes are not RSS.
Existing terrain/simulation formats and goldens are unchanged. Field snapshot v1
is a buffer codec, not LocalWorldFiles publication or combined terrain/biology
durability. Rate sources and their interval/residual persistence are not enabled.
Linux/UBSan, target-host performance, allocator-failure injection and cluster recovery
were not executed locally. Existing Linux CTest CI includes the new test. No deployment
or World0 operation occurred. Next: M6.3 read-only environment views.
+88
View File
@@ -0,0 +1,88 @@
# M6.2 optional environmental fields
[ADR-0051](../adr/0051-optional-environmental-fields.md) scopes `FieldStore`.
Its public API is `include/evo/world/fields.hpp`; it has no I/O, threads or biology.
## Ownership and creation
The store owns 1..4096 fixed sites in strict voxel-address order. Site index is a
stable local ID. Sites have valid one-voxel HabitatBoxes and a substrate material
from M5's table v1. Distinct voxels ensure boxes cannot overlap within this store.
The host must prevent ownership overlap with other stores and bind world/frame.
Creating another store is an independent fixture branch, not additional live supply.
Opening ID is nonzero, immutable host provenance; it is not verified externally.
Water capacity defaults for materials 0/1/2 are supplied explicitly and stored.
Capacity is not water, pore geometry, density or an extraction grant. Water must
not exceed its site's capacity, including transfers and restore. Zero capacity
allows only zero stored water; moisture remains undefined there per M6.1.
Substrate declarations are immutable field metadata. M6.4 must establish a coupled
geometry revision before terrain edits can change habitat capacity or substrate.
Optional channels: water; dissolved N, P; organic C, N, P, other, chemical energy;
incident energy; heat. Scalar matter uses fg and energy uses pJ. Channel identity
preserves compartments. Water contributes to `other`, dissolved/organic components
to their named elements, and all energy compartments to energy. The sum of each
conserved channel must fit u64 at creation/restore. Organic mass and total biomass
are derived; there is no second biomass inventory. Missing channels return `missing`,
not zero. A present all-zero field stays present through encoding and restore.
Opening spans contain either one value repeated at all sites or exactly site-count
values. Channels must be supplied in increasing enum order without duplicates.
No default stock is generated from a material, absent page, restore or read.
No sites/fields can be added after creation in v1.
## Storage, operations and bounds
Each present channel uses site zero's scalar as baseline. A 64-site page allocates
64 u64 values only if any valid value differs; the last page's padding is zero.
No pages are allocated for a uniform field. Memory accounting is
`sizeof(FieldStore) + site_count*sizeof(FieldSite) + allocated_pages*512`.
An operation reserves an additional 32768-byte scalar scratch allowance and charges
old plus new channel pages during replacement; this is accounted memory, not RSS.
Caller input/output buffers, allocator headers and small stack metadata are excluded.
Restore additionally uses at most 327680 bytes of dense field staging, a second
`site_count*sizeof(FieldSite)` mapping array and at most ten opening-span records,
outside the resident budget. All counts are bounded before those allocations.
`read(site, channel)` returns the owned scalar in that channel's units; it grants
no consumption permission. M6.3 will add derived footprint/tick/revision views.
`transfer(action, channel, from, to, amount)` moves a positive quantity between
distinct sites within one present field. It checks source, overflow, water capacity,
fresh nonzero command and replacement budget before publishing. Rejection preserves
all quantities and watermark. Same/older commands reject, never execute again.
This storage primitive cannot feed an organism, convert compartments or create heat.
It transfers no terrain volume. M6.4 supplies coordinated biological transactions.
Empty input, bad material, invalid box, duplicate voxel/channel, mismatched span,
sum overflow and insufficient budgets fail explicitly. Allocation exceptions
propagate to the host; candidates are detached until success. Stores are noncopyable
and nonmovable; scalar reads return values and retain no lifetime-sensitive views.
## Persistence and compatibility
[Snapshot schema](../../schemas/world-fields-v1.md) encodes logical quantities
independently of pages. It includes world/frame, nonzero opening identity, material
defaults, mapping, channel presence and transfer watermark. Canonical decode/re-encode
must match exactly. Runtime byte budgets and pointers are not persisted.
No old/unknown version is migrated implicitly; checksums detect accidental corruption
only. Restoring a field snapshot never calls the terrain generator.
Snapshot buffers are not durable publication. M5 LocalWorldFiles does not save these
fields and must not be advertised as recovering a coupled environment. M6.8/M7 must
publish a version bundle and ownership boundary across terrain, fields and biology.
There are no configured rate sources in v1, so no fractional rate state exists to
restore. Introducing rates requires explicit serialized residual/interval state.
Tests measure uniform, sparse and fully varying resident footprints, exhaust a
finite source into another site, reject overspending without mutation, restore the
depleted state and continue deterministically. Codec tests cover truncation, checksum,
version, identity, shape, channel order, capacity and total-overflow rejection, and
bounded repaired-checksum mutation smoke. Next: M6.3 environment read views.
Measured Windows x64/MSVC 19.44 fixture (130 sites): uniform or absent fields use
15768 accounted resident bytes; one varying 64-site page uses 16280; three varying
pages use 17304. A single present channel serializes to 10756 bytes regardless of
resident layout. These are owned-storage observations, not peak RSS or planetary
capacity claims. Test assertions use relative page costs so ABI metadata differences
do not falsely fail another supported platform.
+5
View File
@@ -131,3 +131,8 @@ M6.2 introduces optional fields, explicit initial inventories and versioned pers
M6.3 read views; M6.4 coordinated ownership/transfer validation; M6.5-6.8 integrated
processes, source budgets and replay. Density/composition conversion, chemical
reactions, global atmosphere/hydrology and cross-region transfer remain unsupported.
M6.2 now implements [optional fields](ENVIRONMENTAL_FIELDS.md) and independent field
snapshots under ADR-0051. Incident energy is finite stock only; no configured rates
or fractional source state exist in field format v1. Enabling rates will require
explicit versioned residual/interval persistence before any integration can commit.
+105
View File
@@ -0,0 +1,105 @@
#pragma once
#include "evo/world/chunks.hpp"
#include "evo/world/environment_units.hpp"
#include <array>
#include <cstddef>
#include <cstdint>
#include <expected>
#include <memory>
#include <span>
namespace evo::world {
enum class Field : std::uint8_t {
water,
nitrogen,
phosphorus,
organic_carbon,
organic_nitrogen,
organic_phosphorus,
organic_other,
organic_energy,
incident_energy,
heat
};
inline constexpr std::size_t field_count = 10;
struct FieldSite {
VoxelAddress voxel;
HabitatBox box;
MaterialId substrate;
};
struct FieldDefaults {
std::array<accounting::Femtograms, 3> water_capacity{};
};
struct FieldOpening {
Field field;
// One value repeated at every site, or exactly site_count values; borrowed during create.
std::span<const std::uint64_t> values;
};
enum class FieldError : std::uint8_t {
config,
mapping,
channel,
missing,
site,
capacity,
overflow,
budget,
stale_command,
invalid_transfer,
insufficient,
format,
version,
identity,
checksum
};
class FieldStore {
public:
static constexpr std::size_t max_sites = 4096;
static constexpr std::size_t scratch_bytes = 32768;
static constexpr std::size_t max_snapshot_bytes = std::size_t{1024} * 1024;
[[nodiscard]] static std::expected<std::unique_ptr<FieldStore>, FieldError>
create(WorldIdentity identity, std::uint64_t opening_id, FieldDefaults defaults,
std::span<const FieldSite> sites, std::span<const FieldOpening> fields,
std::size_t byte_budget);
FieldStore(const FieldStore&) = delete;
FieldStore& operator=(const FieldStore&) = delete;
FieldStore(FieldStore&&) = delete;
FieldStore& operator=(FieldStore&&) = delete;
[[nodiscard]] std::expected<std::uint64_t, FieldError> read(std::size_t site,
Field field) const noexcept;
[[nodiscard]] std::expected<void, FieldError> transfer(std::uint64_t command, Field field,
std::size_t from, std::size_t to,
std::uint64_t amount);
[[nodiscard]] WorldBytes snapshot() const;
[[nodiscard]] static std::expected<std::unique_ptr<FieldStore>, FieldError>
restore(std::span<const std::uint8_t> bytes, WorldIdentity identity, std::size_t byte_budget);
[[nodiscard]] std::size_t accounted_bytes() const noexcept {
return bytes_;
}
[[nodiscard]] std::uint64_t last_command() const noexcept {
return command_;
}
[[nodiscard]] std::span<const FieldSite> sites() const noexcept {
return {sites_.get(), count_};
}
private:
using Page = std::array<std::uint64_t, 64>;
struct Channel {
bool present{};
std::uint64_t baseline{};
std::array<std::unique_ptr<Page>, max_sites / 64> pages;
[[nodiscard]] std::uint64_t get(std::size_t site) const noexcept;
[[nodiscard]] std::size_t bytes() const noexcept;
};
FieldStore() = default;
static std::size_t page_bytes(std::span<const std::uint64_t> values) noexcept;
static Channel encode(std::span<const std::uint64_t> values);
WorldIdentity identity_{};
std::uint64_t opening_{}, command_{};
FieldDefaults defaults_{};
std::size_t count_{}, budget_{}, bytes_{};
std::unique_ptr<FieldSite[]> sites_;
std::array<Channel, field_count> fields_;
};
} // namespace evo::world
+35
View File
@@ -0,0 +1,35 @@
# Environmental field snapshot v1
All integers explicit little endian; signed coordinates use two's-complement u64
encoding. No struct padding. Unknown formats/units/material versions reject.
| Offset | Type | Meaning |
|---:|---|---|
| 0 | 8 bytes | ASCII AEVOFLD1 |
| 8 | u32 | format=1 |
| 12 | u32 | total length including checksum |
| 16,24 | u64 each | nonzero world, frame |
| 32,36 | u32 each | environmental units=1, material table=1 |
| 40,48 | u64 each | nonzero opening provenance, last transfer command (initially 0) |
| 56 | u32 | sites, 1..4096 |
| 60 | u32 | presence bits 0..9 only, enum order in fields.hpp |
| 64 | 3*u64 | water capacities in fg for material 0,1,2 |
| 88 | site_count*74 bytes | sorted site records |
| following | present_count*site_count*u64 | scalar logical arrays, increasing channel order |
| final 8 | u64 | FNV-1a of all preceding bytes; corruption detection only |
Each site: signed X/Y/Z (24 bytes), box origin X/Y/Z and width/height/depth in um
(48 bytes), material ID u16. Strictly increasing voxel addresses; valid one-voxel
box and material 0..2. No duplicate habitat in a voxel. Field arrays contain finite
per-site quantities, including repeated uniform values; absent differs from zero.
Water capacity and global per-energy/element sums are validated on restore.
Length must equal `96 + sites*(74 + 8*present)` (maximum 630880), also bounded by
the API's 1 MiB envelope. All structural counts/lengths are checked before staging
allocations. Canonical encoding omits storage layout, byte budget and pointers.
No rates/residuals exist in v1: incident energy is finite stock only. Adding rate
sources requires explicit versioned persistence, not default construction on restore.
M5 world snapshots are a distinct format and cannot stand in for missing fields.
Codec buffers do not publish durable state. Field/terrain/biology consistency and
recovery bundles remain later gates; LocalWorldFiles handles M5 terrain only.
+291
View File
@@ -0,0 +1,291 @@
#include "evo/world/fields.hpp"
#include <algorithm>
#include <limits>
#include <utility>
#include <vector>
namespace evo::world {
namespace {
constexpr auto ceiling = std::numeric_limits<std::uint64_t>::max();
constexpr std::array<std::size_t, field_count> conserved_channel{4, 2, 3, 1, 2, 3, 4, 0, 0, 0};
std::size_t index(Field field) noexcept {
return static_cast<std::size_t>(field);
}
std::uint64_t value_at(std::span<const std::uint64_t> values, std::size_t i) noexcept {
return values[values.size() == 1 ? 0 : i];
}
} // namespace
std::uint64_t FieldStore::Channel::get(std::size_t site) const noexcept {
const auto& page = pages[site / 64];
return page ? (*page)[site % 64] : baseline;
}
std::size_t FieldStore::Channel::bytes() const noexcept {
std::size_t total{};
for (const auto& page : pages)
if (page)
total += sizeof(Page);
return total;
}
std::size_t FieldStore::page_bytes(std::span<const std::uint64_t> values) noexcept {
std::size_t total{};
for (std::size_t start = 0; start < values.size(); start += 64) {
const auto end = std::min(start + 64, values.size());
for (auto i = start; i < end; ++i) {
if (values[i] != values[0]) {
total += sizeof(Page);
break;
}
}
}
return total;
}
FieldStore::Channel FieldStore::encode(std::span<const std::uint64_t> values) {
Channel out;
out.present = true;
out.baseline = values[0];
for (std::size_t start = 0; start < values.size(); start += 64) {
const auto end = std::min(start + 64, values.size());
bool changed{};
for (auto i = start; i < end; ++i)
changed |= values[i] != out.baseline;
if (!changed)
continue;
auto page = std::make_unique<Page>();
for (auto i = start; i < end; ++i)
(*page)[i - start] = values[i];
out.pages[start / 64] = std::move(page);
}
return out;
}
std::expected<std::unique_ptr<FieldStore>, FieldError>
FieldStore::create(WorldIdentity identity, std::uint64_t opening_id, FieldDefaults defaults,
std::span<const FieldSite> sites, std::span<const FieldOpening> fields,
std::size_t byte_budget) {
if (identity.world == 0 || identity.frame == 0 || opening_id == 0 || sites.empty() ||
sites.size() > max_sites || fields.size() > field_count)
return std::unexpected{FieldError::config};
for (std::size_t i = 0; i < sites.size(); ++i) {
const auto& s = sites[i];
if (!split(s.voxel, base_chunk_edge) || !measure_habitat(s.box) ||
s.substrate.value >= defaults.water_capacity.size() ||
(i != 0 && !(sites[i - 1].voxel < s.voxel)))
return std::unexpected{FieldError::mapping};
}
std::size_t bytes = sizeof(FieldStore) + sites.size() * sizeof(FieldSite);
std::array<std::uint64_t, 5> totals{};
std::size_t prior{};
bool first = true;
for (const auto& f : fields) {
const auto k = index(f.field);
if (k >= field_count || (!first && k <= prior) ||
(f.values.size() != 1 && f.values.size() != sites.size()))
return std::unexpected{FieldError::channel};
first = false;
prior = k;
bytes += page_bytes(f.values);
for (std::size_t i = 0; i < sites.size(); ++i) {
const auto value = value_at(f.values, i);
if (f.field == Field::water &&
value > defaults.water_capacity[sites[i].substrate.value].value)
return std::unexpected{FieldError::capacity};
auto& total = totals[conserved_channel[k]];
if (value > ceiling - total)
return std::unexpected{FieldError::overflow};
total += value;
}
}
if (bytes > byte_budget || scratch_bytes > byte_budget - bytes)
return std::unexpected{FieldError::budget};
auto out = std::unique_ptr<FieldStore>(new FieldStore);
out->identity_ = identity;
out->opening_ = opening_id;
out->defaults_ = defaults;
out->count_ = sites.size();
out->budget_ = byte_budget;
out->bytes_ = bytes;
out->sites_ = std::make_unique<FieldSite[]>(sites.size());
std::copy(sites.begin(), sites.end(), out->sites_.get());
for (const auto& f : fields)
out->fields_[index(f.field)] = encode(f.values);
return out;
}
std::expected<std::uint64_t, FieldError> FieldStore::read(std::size_t site,
Field field) const noexcept {
if (site >= count_)
return std::unexpected{FieldError::site};
if (index(field) >= field_count)
return std::unexpected{FieldError::channel};
if (!fields_[index(field)].present)
return std::unexpected{FieldError::missing};
return fields_[index(field)].get(site);
}
std::expected<void, FieldError> FieldStore::transfer(std::uint64_t command, Field field,
std::size_t from, std::size_t to,
std::uint64_t amount) {
if (command == 0 || command <= command_)
return std::unexpected{FieldError::stale_command};
if (amount == 0 || from == to)
return std::unexpected{FieldError::invalid_transfer};
const auto source = read(from, field), destination = read(to, field);
if (!source)
return std::unexpected{source.error()};
if (!destination)
return std::unexpected{destination.error()};
if (amount > *source)
return std::unexpected{FieldError::insufficient};
if (amount > ceiling - *destination)
return std::unexpected{FieldError::overflow};
if (field == Field::water &&
*destination + amount > defaults_.water_capacity[sites_[to].substrate.value].value)
return std::unexpected{FieldError::capacity};
std::array<std::uint64_t, max_sites> values{};
auto& channel = fields_[index(field)];
for (std::size_t i = 0; i < count_; ++i)
values[i] = channel.get(i);
values[from] -= amount;
values[to] += amount;
const auto logical = std::span{values}.first(count_);
const auto needed = page_bytes(logical);
if (needed > budget_ - bytes_ - scratch_bytes)
return std::unexpected{FieldError::budget};
auto replacement = encode(logical);
bytes_ = bytes_ - channel.bytes() + needed;
channel = std::move(replacement);
command_ = command;
return {};
}
namespace {
constexpr std::uint64_t magic = 0x31444c464f564541ULL; // AEVOFLD1
std::uint64_t checksum(std::span<const std::uint8_t> bytes) noexcept {
std::uint64_t h = 14695981039346656037ULL;
for (auto b : bytes)
h = (h ^ b) * 1099511628211ULL;
return h;
}
void put(WorldBytes& out, std::uint64_t value, unsigned width) {
for (unsigned i = 0; i < width; ++i) {
out.push_back(static_cast<std::uint8_t>(value & 255U));
value >>= 8U;
}
}
struct Reader {
std::span<const std::uint8_t> bytes;
std::size_t at{};
bool ok{true};
std::uint64_t get(unsigned width) noexcept {
if (!ok || width > bytes.size() - at) {
ok = false;
return 0;
}
std::uint64_t value{};
for (unsigned i = 0; i < width; ++i)
value |= std::uint64_t{bytes[at++]} << (8U * i);
return value;
}
std::int64_t signed64() noexcept {
const auto n = get(8);
return n <= static_cast<std::uint64_t>(std::numeric_limits<std::int64_t>::max())
? static_cast<std::int64_t>(n)
: -1 - static_cast<std::int64_t>(~n);
}
};
} // namespace
WorldBytes FieldStore::snapshot() const {
std::uint32_t mask{};
std::size_t present{};
for (std::size_t k = 0; k < field_count; ++k)
if (fields_[k].present) {
mask |= 1U << k;
++present;
}
const auto length = 96 + count_ * (74 + 8 * present);
WorldBytes out;
out.reserve(length);
put(out, magic, 8);
put(out, 1, 4);
put(out, length, 4);
put(out, identity_.world, 8);
put(out, identity_.frame, 8);
put(out, environmental_units_version, 4);
put(out, 1, 4);
put(out, opening_, 8);
put(out, command_, 8);
put(out, count_, 4);
put(out, mask, 4);
for (const auto cap : defaults_.water_capacity)
put(out, cap.value, 8);
for (const auto& site : sites()) {
put(out, static_cast<std::uint64_t>(site.voxel.x), 8);
put(out, static_cast<std::uint64_t>(site.voxel.y), 8);
put(out, static_cast<std::uint64_t>(site.voxel.z), 8);
for (const auto value :
{site.box.x, site.box.y, site.box.z, site.box.width, site.box.height, site.box.depth})
put(out, value.value, 8);
put(out, site.substrate.value, 2);
}
for (const auto& field : fields_)
if (field.present)
for (std::size_t i = 0; i < count_; ++i)
put(out, field.get(i), 8);
put(out, checksum(out), 8);
return out;
}
std::expected<std::unique_ptr<FieldStore>, FieldError>
FieldStore::restore(std::span<const std::uint8_t> bytes, WorldIdentity identity,
std::size_t byte_budget) {
if (bytes.size() < 96 || bytes.size() > max_snapshot_bytes)
return std::unexpected{FieldError::format};
Reader r{bytes.first(bytes.size() - 8)};
if (r.get(8) != magic)
return std::unexpected{FieldError::format};
if (r.get(4) != 1)
return std::unexpected{FieldError::version};
if (r.get(4) != bytes.size())
return std::unexpected{FieldError::format};
Reader tail{bytes.last(8)};
if (checksum(r.bytes) != tail.get(8))
return std::unexpected{FieldError::checksum};
const WorldIdentity stored{r.get(8), r.get(8)};
if (identity.world == 0 || identity.frame == 0 || identity != stored)
return std::unexpected{FieldError::identity};
if (r.get(4) != environmental_units_version || r.get(4) != 1)
return std::unexpected{FieldError::version};
const auto opening = r.get(8), command = r.get(8), count = r.get(4), mask = r.get(4);
if (count == 0 || count > max_sites || mask >= (1U << field_count))
return std::unexpected{FieldError::format};
std::size_t present{};
for (std::size_t k = 0; k < field_count; ++k)
if ((mask & (std::uint64_t{1} << k)) != 0)
++present;
if (bytes.size() != 96 + count * (74 + 8 * present))
return std::unexpected{FieldError::format};
FieldDefaults defaults;
for (auto& cap : defaults.water_capacity)
cap.value = r.get(8);
std::vector<FieldSite> sites(static_cast<std::size_t>(count));
for (auto& site : sites) {
site.voxel = {r.signed64(), r.signed64(), r.signed64()};
site.box = {{r.get(8)}, {r.get(8)}, {r.get(8)}, {r.get(8)}, {r.get(8)}, {r.get(8)}};
site.substrate = {static_cast<std::uint16_t>(r.get(2))};
}
std::array<std::vector<std::uint64_t>, field_count> data;
std::vector<FieldOpening> fields;
fields.reserve(present);
for (std::size_t k = 0; k < field_count; ++k) {
if ((mask & (std::uint64_t{1} << k)) == 0)
continue;
data[k].resize(static_cast<std::size_t>(count));
for (auto& v : data[k])
v = r.get(8);
fields.push_back({static_cast<Field>(k), data[k]});
}
if (!r.ok || r.at != r.bytes.size())
return std::unexpected{FieldError::format};
auto out = create(identity, opening, defaults, sites, fields, byte_budget);
if (!out)
return out;
(*out)->command_ = command;
return out;
}
} // namespace evo::world
+305
View File
@@ -0,0 +1,305 @@
#include "evo/world/fields.hpp"
#include <algorithm>
#include <array>
#include <cstdio>
#include <limits>
#include <source_location>
#include <stdexcept>
#include <string>
#include <vector>
namespace {
using namespace evo::world;
constexpr WorldIdentity identity{7, 9};
constexpr std::size_t budget = 2'000'000;
constexpr auto maximum = std::numeric_limits<std::uint64_t>::max();
void check(bool ok, std::source_location at = std::source_location::current()) {
if (!ok)
throw std::runtime_error("world fields line " + std::to_string(at.line()));
}
#define CHECK(...) check(static_cast<bool>(__VA_ARGS__))
template <typename T> bool refused(const std::expected<T, FieldError>& result, FieldError error) {
return !result && result.error() == error;
}
std::vector<FieldSite> sites(std::size_t count) {
std::vector<FieldSite> out(count);
for (std::size_t i = 0; i < count; ++i)
out[i] = {{static_cast<std::int64_t>(i), 0, -1}, {{0}, {0}, {0}, {10}, {20}, {3}}, {1}};
return out;
}
FieldDefaults defaults() {
return {{evo::accounting::Femtograms{0}, evo::accounting::Femtograms{1000},
evo::accounting::Femtograms{2000}}};
}
std::unique_ptr<FieldStore> make(std::span<const FieldSite> mapping,
std::span<const FieldOpening> opening,
std::size_t limit = budget) {
auto out = FieldStore::create(identity, 11, defaults(), mapping, opening, limit);
CHECK(out);
return std::move(*out);
}
void put(WorldBytes& bytes, std::size_t offset, std::uint64_t value, unsigned width) {
for (unsigned i = 0; i < width; ++i) {
bytes.at(offset + i) = static_cast<std::uint8_t>(value & 255U);
value >>= 8U;
}
}
void seal(WorldBytes& bytes) {
put(bytes, 12, bytes.size(), 4);
std::uint64_t h = 14695981039346656037ULL;
for (std::size_t i = 0; i < bytes.size() - 8; ++i)
h = (h ^ bytes[i]) * 1099511628211ULL;
put(bytes, bytes.size() - 8, h, 8);
}
void storage_and_exhaustion() {
const auto mapping = sites(130);
const std::uint64_t zero = 0, seven = 7;
auto absent = make(mapping, {});
const FieldOpening uniform[]{{Field::water, {&seven, 1}}, {Field::nitrogen, {&zero, 1}}};
auto compact = make(mapping, uniform);
CHECK(absent->accounted_bytes() == compact->accounted_bytes());
CHECK(refused(absent->read(0, Field::water), FieldError::missing));
CHECK(compact->read(129, Field::nitrogen) == 0);
CHECK(compact->read(129, Field::water) == 7);
std::vector<std::uint64_t> values(130, seven);
values.back() = 9;
const FieldOpening sparse_input[]{{Field::water, values}};
auto sparse = make(mapping, sparse_input);
CHECK(sparse->accounted_bytes() == compact->accounted_bytes() + 512);
for (std::size_t i = 0; i < values.size(); ++i)
CHECK(sparse->read(i, Field::water) == values[i]);
for (std::size_t i = 0; i < values.size(); ++i)
values[i] = i;
auto varied = make(mapping, sparse_input);
CHECK(varied->accounted_bytes() == compact->accounted_bytes() + 1536);
CHECK(varied->snapshot().size() == 96 + 130 * (74 + 8));
std::printf("field bytes: uniform=%zu sparse=%zu varying=%zu\n", compact->accounted_bytes(),
sparse->accounted_bytes(), varied->accounted_bytes());
const auto prior = varied->snapshot();
CHECK(refused(varied->transfer(1, Field::water, 64, 63, 65), FieldError::insufficient));
CHECK(varied->snapshot() == prior);
CHECK(varied->transfer(1, Field::water, 64, 63, 64));
CHECK(varied->read(64, Field::water) == 0);
CHECK(varied->read(63, Field::water) == 127);
const auto depleted = varied->snapshot();
CHECK(refused(varied->transfer(2, Field::water, 64, 63, 1), FieldError::insufficient));
CHECK(refused(varied->transfer(1, Field::water, 64, 63, 64), FieldError::stale_command));
CHECK(varied->snapshot() == depleted);
auto restored = FieldStore::restore(depleted, identity, budget);
CHECK(restored && (*restored)->snapshot() == depleted);
CHECK((*restored)->read(64, Field::water) == 0);
CHECK((*restored)->transfer(2, Field::water, 63, 64, 64));
CHECK(varied->transfer(2, Field::water, 63, 64, 64));
CHECK((*restored)->snapshot() == varied->snapshot());
std::uint64_t total{};
for (std::size_t i = 0; i < 130; ++i) {
CHECK(varied->read(i, Field::water) == i);
total += *varied->read(i, Field::water);
}
CHECK(total == 8385);
CHECK(compact->transfer(1, Field::water, 128, 129, 7));
CHECK(compact->accounted_bytes() == absent->accounted_bytes() + 512);
CHECK(compact->transfer(2, Field::water, 129, 128, 7));
CHECK(compact->accounted_bytes() == absent->accounted_bytes());
const auto tight_budget = compact->accounted_bytes() + FieldStore::scratch_bytes;
auto tight = make(mapping, uniform, tight_budget);
const auto before = tight->snapshot();
CHECK(refused(tight->transfer(1, Field::water, 0, 1, 1), FieldError::budget));
CHECK(tight->snapshot() == before);
CHECK(refused(FieldStore::restore(before, identity, tight_budget - 1), FieldError::budget));
auto absent_copy = FieldStore::restore(absent->snapshot(), identity, budget);
CHECK(absent_copy && refused((*absent_copy)->read(1, Field::water), FieldError::missing));
auto zero_copy = FieldStore::restore(compact->snapshot(), identity, budget);
CHECK(zero_copy && (*zero_copy)->read(1, Field::nitrogen) == 0);
}
void invalid_openings_and_transfers() {
auto mapping = sites(2);
const std::uint64_t zero = 0, full = 1000, one = 1;
const FieldOpening water[]{{Field::water, {&full, 1}}};
auto store = make(mapping, water);
const auto before = store->snapshot();
CHECK(refused(store->transfer(1, Field::water, 0, 1, 1), FieldError::capacity));
CHECK(refused(store->transfer(1, Field::water, 0, 0, 1), FieldError::invalid_transfer));
CHECK(refused(store->transfer(1, Field::water, 0, 1, 0), FieldError::invalid_transfer));
CHECK(refused(store->transfer(0, Field::water, 0, 1, 1), FieldError::stale_command));
CHECK(refused(store->transfer(1, Field::water, 0, 2, 1), FieldError::site));
CHECK(refused(store->transfer(1, Field::nitrogen, 0, 1, 1), FieldError::missing));
// Fixed uint8_t underlying type permits hostile raw enum values; validate at the API.
// NOLINTNEXTLINE(clang-analyzer-optin.core.EnumCastOutOfRange)
CHECK(refused(store->read(0, static_cast<Field>(255)), FieldError::channel));
CHECK(store->snapshot() == before);
CHECK(refused(FieldStore::create(identity, 0, defaults(), mapping, water, budget),
FieldError::config));
CHECK(refused(FieldStore::create({}, 11, defaults(), mapping, water, budget),
FieldError::config));
const FieldOpening duplicate[]{{Field::water, {&zero, 1}}, {Field::water, {&zero, 1}}};
CHECK(refused(FieldStore::create(identity, 11, defaults(), mapping, duplicate, budget),
FieldError::channel));
const FieldOpening invalid[]{{Field::water, {}}};
CHECK(refused(FieldStore::create(identity, 11, defaults(), mapping, invalid, budget),
FieldError::channel));
mapping[1].voxel = mapping[0].voxel;
CHECK(refused(FieldStore::create(identity, 11, defaults(), mapping, water, budget),
FieldError::mapping));
mapping = sites(2);
mapping[0].box.depth.value = 0;
CHECK(refused(FieldStore::create(identity, 11, defaults(), mapping, water, budget),
FieldError::mapping));
mapping = sites(2);
mapping[0].substrate = {3};
CHECK(refused(FieldStore::create(identity, 11, defaults(), mapping, water, budget),
FieldError::mapping));
mapping = sites(2);
const FieldOpening repeated_overflow[]{{Field::nitrogen, {&maximum, 1}}};
CHECK(refused(FieldStore::create(identity, 11, defaults(), mapping, repeated_overflow, budget),
FieldError::overflow));
const std::uint64_t max_once[]{maximum, 0};
for (const auto pair : {std::array{Field::nitrogen, Field::organic_nitrogen},
std::array{Field::phosphorus, Field::organic_phosphorus},
std::array{Field::organic_energy, Field::heat}}) {
const FieldOpening overflow[]{{pair[0], max_once}, {pair[1], {&one, 1}}};
CHECK(refused(FieldStore::create(identity, 11, defaults(), mapping, overflow, budget),
FieldError::overflow));
}
const FieldOpening organic[]{{Field::organic_other, {&one, 1}}};
auto isolated = make(mapping, organic);
CHECK(refused(isolated->read(0, Field::water), FieldError::missing));
}
void codec_validation() {
const auto mapping = sites(2);
const std::uint64_t amount = 4;
const FieldOpening input[]{{Field::water, {&amount, 1}}};
auto store = make(mapping, input);
const auto bytes = store->snapshot();
CHECK(bytes.size() == 260);
for (std::size_t length = 0; length < bytes.size(); ++length)
CHECK(!FieldStore::restore(std::span{bytes}.first(length), identity, budget));
CHECK(refused(FieldStore::restore(bytes, {7, 10}, budget), FieldError::identity));
auto changed = bytes;
changed[200] ^= 1;
CHECK(refused(FieldStore::restore(changed, identity, budget), FieldError::checksum));
for (const auto offset : {8U, 32U, 36U}) {
for (const auto version : {0U, 2U}) {
changed = bytes;
put(changed, offset, version, 4);
seal(changed);
CHECK(refused(FieldStore::restore(changed, identity, budget), FieldError::version));
}
}
for (const auto mutation : {std::array<std::uint64_t, 3>{40, 0, 8}, // opening ID
{56, 4097, 4},
{60, 1024, 4}, // count/mask
{88, 1048576, 8},
{112, 1000000, 8}, // address/box
{160, 3, 2},
{236, 1001, 8}}) { // material/water
changed = bytes;
put(changed, static_cast<std::size_t>(mutation[0]), mutation[1],
static_cast<unsigned>(mutation[2]));
seal(changed);
CHECK(!FieldStore::restore(changed, identity, budget));
}
changed = bytes;
std::copy_n(changed.begin() + 88, 24, changed.begin() + 162);
seal(changed);
CHECK(refused(FieldStore::restore(changed, identity, budget), FieldError::mapping));
changed = bytes;
changed.push_back(0);
seal(changed);
CHECK(!FieldStore::restore(changed, identity, budget));
// Repaired checksums reach semantic parsing. Accepted inputs must be canonical.
for (std::size_t n = 0; n < 256; ++n) {
changed = bytes;
changed[(n * 37) % (bytes.size() - 8)] ^= static_cast<std::uint8_t>(1U << (n % 8));
seal(changed);
auto decoded = FieldStore::restore(changed, identity, budget);
if (decoded)
CHECK((*decoded)->snapshot() == changed);
}
// Independent byte construction of an absent-field, single-site fixture.
const auto one = sites(1);
auto empty = make(one, {});
WorldBytes expected(170, 0);
const std::string magic = "AEVOFLD1";
std::copy(magic.begin(), magic.end(), expected.begin());
put(expected, 8, 1, 4);
put(expected, 16, 7, 8);
put(expected, 24, 9, 8);
put(expected, 32, 1, 4);
put(expected, 36, 1, 4);
put(expected, 40, 11, 8);
put(expected, 56, 1, 4);
put(expected, 72, 1000, 8);
put(expected, 80, 2000, 8);
put(expected, 104, maximum, 8);
put(expected, 136, 10, 8);
put(expected, 144, 20, 8);
put(expected, 152, 3, 8);
put(expected, 160, 1, 2);
seal(expected);
CHECK(empty->snapshot() == expected);
}
void all_channels_and_limits() {
const auto mapping = sites(FieldStore::max_sites);
std::array<std::vector<std::uint64_t>, field_count> values;
std::array<FieldOpening, field_count> openings;
for (std::size_t k = 0; k < field_count; ++k) {
values[k].resize(mapping.size());
for (std::size_t i = 0; i < mapping.size(); ++i)
values[k][i] = (i + k) % 100;
openings[k] = {static_cast<Field>(k), values[k]};
}
auto store = make(mapping, openings);
const auto encoded = store->snapshot();
CHECK(encoded.size() == 630880);
auto restored = FieldStore::restore(encoded, identity, budget);
CHECK(restored && (*restored)->snapshot() == encoded);
for (std::size_t k = 0; k < field_count; ++k)
for (std::size_t i = 0; i < mapping.size(); ++i)
CHECK((*restored)->read(i, static_cast<Field>(k)) == values[k][i]);
// Independent dense model across page seams and all compartment types.
for (std::uint64_t command = 1; command <= 100; ++command) {
const auto k = static_cast<std::size_t>(command % field_count);
const auto from = static_cast<std::size_t>((command * 63) % mapping.size());
const auto to = (from + 1) % mapping.size();
const auto amount = values[k][from];
if (amount == 0)
continue;
CHECK((*restored)->transfer(command, static_cast<Field>(k), from, to, amount));
values[k][from] = 0;
values[k][to] += amount;
CHECK((*restored)->read(from, static_cast<Field>(k)) == 0);
CHECK((*restored)->read(to, static_cast<Field>(k)) == values[k][to]);
}
auto continued = FieldStore::restore((*restored)->snapshot(), identity, budget);
CHECK(continued && (*continued)->last_command() == (*restored)->last_command());
for (std::size_t k = 0; k < field_count; ++k)
for (std::size_t i = 0; i < mapping.size(); ++i)
CHECK((*continued)->read(i, static_cast<Field>(k)) == values[k][i]);
const auto too_many = sites(FieldStore::max_sites + 1);
CHECK(refused(FieldStore::create(identity, 11, defaults(), too_many, {}, budget),
FieldError::config));
CHECK(
refused(FieldStore::create(identity, 11, defaults(), {}, {}, budget), FieldError::config));
WorldBytes oversized(FieldStore::max_snapshot_bytes + 1);
CHECK(refused(FieldStore::restore(oversized, identity, budget), FieldError::format));
// Global overflow below a valid checksum and structurally correct shape.
auto corrupt = encoded;
const auto data_start = std::size_t{88} + mapping.size() * 74;
put(corrupt, data_start + mapping.size() * 8, maximum, 8); // nitrogen[0]
seal(corrupt);
CHECK(refused(FieldStore::restore(corrupt, identity, budget), FieldError::overflow));
}
} // namespace
int main() try {
storage_and_exhaustion();
invalid_openings_and_transfers();
codec_validation();
all_channels_and_limits();
return 0;
} catch (const std::exception& e) {
std::fprintf(stderr, "%s\n", e.what());
return 1;
} catch (...) {
return 1;
}