From 4c70257883ac73b29e8be7fbe8c91ca972f9cf3e Mon Sep 17 00:00:00 2001 From: dingo Date: Mon, 19 Oct 2026 16:05:17 -0400 Subject: [PATCH] feat(ecology): own cells and their local environment together ADR-0172 records the maintainer's M12.5 ownership decision: one owner per patch of space for cells and their local environment, reserves belonging to the biological individual, and an open planet boundary whose every crossing is a recorded import or export. The portable CellularEnvironment owner (envelope AEVOCEN1) holds an exact population with tagged water and dissolved compartments, refuses declared atmosphere, imports infall from finite per-source entitlements (ADR-0136 step B) and radiates retained heat. Each tick's exchange is a validated swap on the nested owner, undone if the biological tick refuses. Closed and source-off regions keep their biology byte for byte; raw and cohort representations agree under infall. No existing format, trace, golden, default opening or live version changes. Co-Authored-By: Claude Opus 5.5 --- CMakeLists.txt | 15 +- .../region/dev-session-route/listener.yaml | 2 +- docs/ROADMAP.md | 6 + docs/STATUS.md | 16 + .../0172-cellular-environment-ownership.md | 124 +++++ docs/adr/README.md | 2 + docs/engineering/M12_DELIVERY_PLAN.md | 2 +- .../M12_ENVIRONMENT_OWNERSHIP_RESOLUTION.md | 9 + docs/engineering/M12_REMAINING_GATES.md | 6 +- docs/engineering/VALIDATION.md | 39 ++ .../server/lifecycle/cellular_environment.hpp | 141 ++++++ .../evo/server/lifecycle/cellular_lives.hpp | 14 + .../server/lifecycle/cellular_population.hpp | 1 + schemas/cellular-environment-v1.md | 46 ++ src/server/lifecycle/cellular_environment.cpp | 460 ++++++++++++++++++ src/server/lifecycle/cellular_lives.cpp | 71 +++ tests/cellular_environment_tests.cpp | 387 +++++++++++++++ 17 files changed, 1335 insertions(+), 6 deletions(-) create mode 100644 docs/adr/0172-cellular-environment-ownership.md create mode 100644 include/evo/server/lifecycle/cellular_environment.hpp create mode 100644 schemas/cellular-environment-v1.md create mode 100644 src/server/lifecycle/cellular_environment.cpp create mode 100644 tests/cellular_environment_tests.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index ed9a217..f03131f 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -94,9 +94,10 @@ add_library(evo_lifecycle STATIC src/server/lifecycle/primitive_lives.cpp src/server/lifecycle/cellular_batch.cpp src/server/lifecycle/wildlife_controller.cpp src/server/lifecycle/cellular_play_summary.cpp src/server/lifecycle/cellular_population.cpp src/server/lifecycle/cellular_population_codec.cpp src/server/lifecycle/cellular_population_policy.cpp - src/server/lifecycle/cellular_schedule.cpp src/server/lifecycle/cellular_population_batch.cpp) + src/server/lifecycle/cellular_schedule.cpp src/server/lifecycle/cellular_population_batch.cpp + src/server/lifecycle/cellular_environment.cpp) add_library(evo::lifecycle ALIAS evo_lifecycle) -target_link_libraries(evo_lifecycle PUBLIC evo::biology) +target_link_libraries(evo_lifecycle PUBLIC evo::biology evo::world) evo_owned_target(evo_lifecycle) add_library(evo_ecology STATIC src/ecology/cohort.cpp src/ecology/collapse.cpp src/ecology/population.cpp src/ecology/materialize.cpp) @@ -705,6 +706,16 @@ if(BUILD_TESTING) -P "${CMAKE_CURRENT_SOURCE_DIR}/tests/cellular_population_restart.cmake") set_tests_properties(cellular-retained-plan-population cellular-retained-plan-population-restart PROPERTIES TIMEOUT ${evo_cohort_timeout}) + add_executable(evo-cellular-environment-tests tests/cellular_environment_tests.cpp) + target_link_libraries(evo-cellular-environment-tests PRIVATE evo::lifecycle) + evo_owned_target(evo-cellular-environment-tests) + add_test(NAME cellular-environment-contracts COMMAND evo-cellular-environment-tests) + add_test(NAME cellular-environment-restart COMMAND "${CMAKE_COMMAND}" + "-DPOPULATION_TEST=$" + "-DTEST_DIR=${CMAKE_CURRENT_BINARY_DIR}/environment-restart" + -P "${CMAKE_CURRENT_SOURCE_DIR}/tests/cellular_population_restart.cmake") + set_tests_properties(cellular-environment-contracts cellular-environment-restart + PROPERTIES TIMEOUT ${evo_cohort_timeout}) add_executable(evo-cellular-inheritance-tests tests/cellular_inheritance_tests.cpp) target_link_libraries(evo-cellular-inheritance-tests PRIVATE evo::lifecycle) evo_owned_target(evo-cellular-inheritance-tests) diff --git a/deploy/kubernetes/region/dev-session-route/listener.yaml b/deploy/kubernetes/region/dev-session-route/listener.yaml index 9fe4ee7..396340f 100644 --- a/deploy/kubernetes/region/dev-session-route/listener.yaml +++ b/deploy/kubernetes/region/dev-session-route/listener.yaml @@ -12,7 +12,7 @@ spec: env: - {name: REGION_SESSION, value: "dev"} - {name: REGION_SESSION_LISTEN, value: "0.0.0.0:7400"} - - {name: REGION_SESSION_WINDOW, value: "dev-20261019T191902-e356d1d1:1792451942"} + - {name: REGION_SESSION_WINDOW, value: "dev-20261019T195802-5aa0ff3e:1792454282"} - {name: REGION_M10_MAX_GRANT_LIFETIME, value: "14400"} ports: # QUIC (ADR-0090): UDP only; nothing listens on TCP 7400. diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md index 0388405..3795137 100644 --- a/docs/ROADMAP.md +++ b/docs/ROADMAP.md @@ -647,6 +647,12 @@ the later multicellular idea are not ratified game rules. ## M12 - Persistent ecology +2026-10-19: [ADR-0172](adr/0172-cellular-environment-ownership.md) accepts one +owner per patch of space for cells and their local environment, individual +reserves and an open planet boundary. The portable joint owner adds finite infall +entitlements and radiative export with exact closure; producers, durable admission +and integration remain open. + 2026-10-19 gameplay clarification: [ADR-0163](adr/0163-structural-inheritance-and-offspring-succession.md) accepts offspring-only structural expression, permanent birth-time parent/child control diff --git a/docs/STATUS.md b/docs/STATUS.md index ea27ef6..1b9ed38 100644 --- a/docs/STATUS.md +++ b/docs/STATUS.md @@ -1,5 +1,21 @@ # Project status and next steps +## Cellular environment ownership (M12.5a-b) - 2026-10-19 + +The maintainer accepted one owner per patch of space for cells and their local +environment, individual reserves (colony/multicellular sharing later) and an open +planet boundary. [ADR-0172](adr/0172-cellular-environment-ownership.md) records +that contract and adds the portable `CellularEnvironment` owner (envelope +`AEVOCEN1`): tagged water/dissolved compartments, refused atmosphere, finite infall +entitlements (ADR-0136 step B) and radiative heat export, applied with each joint +tick or not at all. Closed and source-off regions keep their biology byte for byte. +Raw and cohort representations agree under infall. Old formats and goldens keep +their meaning; no default/live version changes. + +Both full Release suites pass **94/94**; see [Validation](engineering/VALIDATION.md). +Producers (ADR-0136 step C), durable admission (12.5c), worker/census/migration +integration (12.5d) and target-host qualification (12.5e) remain open. + ## Portable retained-plan exact populations - 2026-10-19 [ADR-0171](adr/0171-retained-plan-exact-populations.md) adds envelope/batch 3 for diff --git a/docs/adr/0172-cellular-environment-ownership.md b/docs/adr/0172-cellular-environment-ownership.md new file mode 100644 index 0000000..49d54c9 --- /dev/null +++ b/docs/adr/0172-cellular-environment-ownership.md @@ -0,0 +1,124 @@ +# ADR-0172: Cellular environment ownership and open-boundary contract + +## Status and scope + +Accepted 2026-10-19. The maintainer accepted the single-owner direction of the +[ownership resolution](../engineering/M12_ENVIRONMENT_OWNERSHIP_RESOLUTION.md) and +clarified its scope. This ADR is M12.5a: the contract that the portable composite +owner (12.5b) implements. It extends ADR-0136 step B, ADR-0144 and ADR-0157/0165. +No default/live version, durable profile, SQL schema, photosynthesis, atmosphere +or M6 fixture change. ADR-0136 step C remains proposed design input. + +## Maintainer clarification + +- **One owner per patch of space, at any moment.** It is not one global owner. + A world is many regions, each with exactly one owner of its cells *and* their + local environment. Stock changes owner only through recorded, paired transfers + (ADR-0147–0149 escrow). This carries forward unchanged to the multicellular 3D + world (M13.8/M14): more and larger owners, never two ledgers for one stock. +- **Reserves belong to the biological individual.** A single cell owns its body + and reserve. A colony or multicellular body sharing resources internally is a + later, separately versioned rule (ADR-0135 colonies, M14.2). Nothing here pools + reserves between organisms or forecloses that rule. +- **The planet is an open system.** Resources may enter or leave the region, and + later the planet as a whole. Every crossing is an explicit, versioned process + recorded as a cumulative import or export. Nothing is minted or deleted silently: + `current = opening + imports − exports`, per channel. Exported stock is gone; it + returns only as a new recorded import. + +## Decision + +`CellularEnvironment` (envelope `AEVOCEN1`, format 1, environment rules 1) takes +exclusive ownership of one exact `CellularPopulation` (raw or cohort; nested owner +7 with rules 8 or 9, or owner 8 with rules 10) and of that region's tagged +environmental compartments. Neither the nested owner nor any copy is separately +spendable while the composite exists. It exposes read-only views only. + +### Geometry + +One declared axis-aligned habitat inside one environmental voxel: voxel address, +micrometre origin and a box whose width and height equal the cellular area and +whose effective depth is positive (`world::measure_habitat`). Depth defines a +sampling volume for concentration views only; it never creates or scales stock. +Organism count and camera size never determine depth or supply. + +### Compartment map, version 1 + +| Compartment | Owner | Edible | v1 processes | +|---|---|---|---| +| Organic energy, C, N, P, other in deposits, lives, corpses, nursery | nested cellular owner | yes (existing contact feeding) | existing biology; infall import | +| Heat (energy) | nested cellular owner | no | radiative export | +| Water | composite | no | none: conserved, audited, never converted | +| Dissolved inorganic N, P | composite | no | none: conserved, audited, never converted | +| Atmospheric species | unsupported | — | declaring any is refused (`unsupported`), never zero or unlimited | +| Incident light | not stock | — | not represented until a producer process exists | + +Cellular `other` means organic other only. `accounting::Inventory` has no water, +dissolved or gas channel, so no generic retag can turn water into food, dissolved +nutrients into edible matter or heat into usable energy. A conversion between +compartments requires a separately versioned process with debit, credit, work, +waste and residual terms. Rules 1 define none. + +### Processes, rules 1 (all coefficients are trial values) + +1. **Infall import (ADR-0136 step B).** At most four sources, sorted unique + nonzero ids, with disjoint rectangles inside the habitat, a half-open active + tick interval and a finite per-channel **entitlement**. On each advancing tick + `t` in its interval a source fires when a SplitMix64 roll of + `(world, region, source, t)` is divisible by its mean interval (trial 2,400 + ticks, two simulated minutes). An event drops `min..max` (trial 12–24) single- + channel bubbles within a 500 µm disc at a seeded centre in the source rectangle, + cycling the channels its per-bubble amount stocks. Each bubble credits + `min(per-bubble amount, remaining entitlement)`. A zero credit, an occupied + address or the 4,096-deposit limit skips that bubble; skips are counted, never + deferred. Credits enter the nested boundary `incoming` and the source's + cumulative `imported`; remaining entitlement is derived, never stored twice. + Exhausted or inactive sources import nothing. Restart, retry and representation + change cannot reset entitlement, because `imported` is persisted. +2. **Radiative heat export.** Each advancing tick exports `min(heat, cap)` pJ of + retained heat (cap per tick is configuration; zero closes the boundary). The + amount enters the nested boundary `outgoing` and the composite's cumulative + export. Heat is never spendable before or after export. + +Infall happens only on advancing ticks, so a region that does not tick (offline, +ADR-0128) imports nothing. There is no catch-up credit. + +### Tick and atomicity + +For advancing tick `t`: derive the exchange from the committed state; apply it to +the nested owner as a validated swap (new habitat, heat and boundary ledger, with +`current = opening + incoming − outgoing` rechecked); then run the unchanged +population tick (shared wildlife controller, controlled intentions, selections). +If the biological tick refuses, the exchange is swapped back and the composite is +byte-for-byte unchanged. Environment progress commits only with the tick. There is +no independently acknowledged environmental or cellular prefix. + +### Envelope and versions + +The envelope stores identity, completed tick, geometry, compartments, radiation +cap and cumulative export, every source with its cumulative import and event/skip +counters, and the complete nested population envelope, with an FNV-1a64 checksum +and byte-identical re-encoding. A nested owner restored alone must not publish a +joint result. Old cellular formats 6/7/8, rules 8/9/10, population envelopes 1–3, +traces and durable bundles 9–11 keep their exact meaning; none gains fields. The +composite admits only nested owners with a boundary ledger (format 7 or 8). + +The nested boundary ledger also carries migration flows (ADR-0144). The composite's +own cumulative import and export distinguish environmental crossings from migration. + +## Consequences + +The open boundary is auditable: replay re-derives every infall from configuration, +tick and seed, and restore continues from persisted cumulative entitlement. Source- +off, exhausted and open worlds become directly comparable. Producers (photosynthesis) +still require ADR-0136 step C's genome capability, coefficients and a capture +process debiting a declared light entitlement; until then 12.5 is not complete. +Durable publication (12.5c), worker/census/migration integration (12.5d) and target- +host qualification (12.5e) remain separate segments. + +## Alternatives + +A copied environmental view, reuse of the M6 two-actor fixture, two independently +committed checkpoints and a generic inventory setter remain rejected (see the +resolution). A single global owner was rejected by the maintainer's clarification: +regions scale by count, not by one shared ledger. diff --git a/docs/adr/README.md b/docs/adr/README.md index cbed044..3f41bb1 100644 --- a/docs/adr/README.md +++ b/docs/adr/README.md @@ -1,5 +1,7 @@ # Architecture decision records +- [ADR-0172: Cellular environment ownership](0172-cellular-environment-ownership.md) - one owner per patch of space for cells and their local environment; reserves stay individual; open planet boundary with recorded imports/exports; portable envelope `AEVOCEN1` with finite infall entitlements and radiative heat export. + - [ADR-0171: Retained-plan exact populations](0171-retained-plan-exact-populations.md) - portable envelope/batch 3 preserve every member's expressed/heritable state, exact conversion/policy replay and projection-2 plan counts; durable admission remains separate. - [ADR-0170: Explicit DEV worker placement](0170-dev-worker-placement.md) - required control-plane/master exclusion for DEV workloads in full and standalone overlays, with rendered-policy regression checks; no live-placement claim. diff --git a/docs/engineering/M12_DELIVERY_PLAN.md b/docs/engineering/M12_DELIVERY_PLAN.md index 560fdbd..e54c04d 100644 --- a/docs/engineering/M12_DELIVERY_PLAN.md +++ b/docs/engineering/M12_DELIVERY_PLAN.md @@ -12,7 +12,7 @@ Commit and push each validated scoped segment separately. | 12.2 | Exact local model selected and paired qualification implemented (12.2d); production cost gate open | ADR-0139, exact canonical equality across 196,608 paired ticks per platform. Regional approximation disabled; no compression claim. Deployment-host capacity and fuller interaction coverage remain open. | | 12.3 | Exact population profile/trace/store and opt-in host integration implemented (12.3b) | ADR-0142, schema 44; exact publication/recovery, mutation race guards, ambiguous replies and process kills. Executable/network population fault drills and target-host qualification remain open. | | 12.4 | Owned intervals and durable paired migration/fault qualification implemented in scoped segments through 12.4l | ADR-0143–0149/schema 49; bounded admitted work, source freeze, staged ghost, atomic pair and exact recovery, local TLS and storage faults. Multi-host/orchestrator, linked ecology and integrated stock audits remain open. | -| 12.5 | Blocked on 12.2-12.4 | Finite M6 process fixtures do not qualify coupled persistent cellular/cohort atmosphere/water budgets. | +| 12.5 | Ownership accepted; portable joint owner implemented (12.5a-b) | ADR-0172: one owner per patch, tagged water/dissolved compartments, finite infall entitlements and radiative export with exact raw/cohort, refusal and restart evidence. Producers (ADR-0136 step C), durable profile, worker integration and target-host qualification remain open. | | 12.6 | Regional queries, replayed history, scoped multi-region queries and consistent database head snapshots implemented (12.6a-d) | ADR-0150–0153; short read-only snapshot capture prevents atomic pairs from straddling declared head sets, with exact immutable replay. Durable world/branch coverage, outside transfer/viability reconciliation, target-host query/index costs and client path remain required. | | 12.7 | Evidence policy, registered coverage, history domains and verified pending handoff evidence implemented (12.7a-c) | ADR-0154–0156/schema 52 captures namespace/registry/heads/pending handoffs together, with exact capsule/ghost replay and supported restore forks. Cross-domain clone provenance, other viable-store coverage and durable accepted global reconciliation/freshness remain required. | | 12.8 | Bounded unscripted generation evidence; actual-days gate not qualified | ADR-0162 measures four real wildlife generations with exact raw/cohort recovery, predation and twins. Actual multi-day integrated ecology/restart/clone evidence remains required. | diff --git a/docs/engineering/M12_ENVIRONMENT_OWNERSHIP_RESOLUTION.md b/docs/engineering/M12_ENVIRONMENT_OWNERSHIP_RESOLUTION.md index d22dae1..6e65e41 100644 --- a/docs/engineering/M12_ENVIRONMENT_OWNERSHIP_RESOLUTION.md +++ b/docs/engineering/M12_ENVIRONMENT_OWNERSHIP_RESOLUTION.md @@ -4,6 +4,15 @@ implementation boundary; it does not declare a new biological rule, accepted producer chemistry, working adapter or completed gate. +**Decision (2026-10-19):** the maintainer accepted the single-owner direction with +three clarifications recorded in [ADR-0172](../adr/0172-cellular-environment-ownership.md): +one owner per patch of space at any moment (many regions, paired transfers between +them, unchanged for the later multicellular 3D world); reserves belong to the +biological individual, with colony/multicellular sharing a later versioned rule; +and the planet is an open system whose every crossing is a recorded import or +export. ADR-0172 is the 12.5a contract and implements the portable 12.5b owner +with finite infall entitlements and radiative heat export. Producers remain open. + ## Concrete conflict `CellularLives` exclusively owns its finite habitat, nursery, living bodies and diff --git a/docs/engineering/M12_REMAINING_GATES.md b/docs/engineering/M12_REMAINING_GATES.md index e70118c..4dccc49 100644 --- a/docs/engineering/M12_REMAINING_GATES.md +++ b/docs/engineering/M12_REMAINING_GATES.md @@ -66,7 +66,7 @@ or authorize production enablement. | 12.2 | Exact cellular model and paired matrix; local samples through 256 lives; bounded four-generation rules-9 predation/twin matrix | Deployment-host tail costs including publication; larger wildlife cohorts and fuller contention coverage; useful compression remains unimplemented. | | 12.3 | Dedicated population profile/trace/store/owning host; exact recovery and private PostgreSQL fault tests | Population-specific executable/network fault drills and target-host publication/capacity qualification. | | 12.4 | Owned intervals; exact transfer/accounting; durable atomic pair/recovery; independent loopback TLS path loss and owner expiry/replacement/heal; local object sync/read-failure matrix | Multi-host/kernel-network, storage-host and orchestrator drills, linked-boundary contracts and integrated ownership/stock audits at scale. | -| 12.5 | Finite cellular contact feeding/decay and separate M6 producer/consumer resource owner | One jointly owned cellular/environment budget, explicit effective depth and source entitlements, versioned water/atmosphere species mapping and producer coefficients, plus closed/open and nutrient-exhaustion comparisons. | +| 12.5 | ADR-0172 portable joint owner: one budget for cells and local environment, effective depth, tagged water/dissolved compartments, refused atmosphere, finite infall entitlements, radiative export; closed/source-off/open/exhaustion and raw/cohort comparisons | Producer process and coefficients (ADR-0136 step C), durable profile/trace/recovery (12.5c), worker/census/migration integration and escrowed cross-worker sources (12.5d), target-host qualification (12.5e). | | 12.6 | Retained archive, regional census/lineage queries, replayed history, scoped multi-region queries and consistent database head snapshots (12.6a-d); registered coverage/history domains follow in 12.7a-b | Cross-domain clone provenance, retained historical coverage/other viable stores, target-host query/index qualification and client permission/presentation; no account power or invented precise statistical ancestry. | | 12.7 | Viability/unknown policy; consistent cuts, registered coverage, history domains/restore forks and verified pending handoff evidence (12.7a-c/schema 52) | Cross-domain clone provenance, other viable-store coverage and durable accepted global evidence records/freshness. Missing/stale/unsupported owners must prevent terminal extinction. | | 12.8 | Deterministic seed/regime drivers, separate-process exact continuation and bounded unscripted generations | Reproducible integrated worlds running for actual days, real restarts/clone comparisons and retained accounting/diversity/cost audits. Accelerated tests cannot supply elapsed days. | @@ -82,7 +82,9 @@ and photosynthesis steps B/C do not silently become accepted M12 mechanics. The [ownership resolution proposal](M12_ENVIRONMENT_OWNERSHIP_RESOLUTION.md) records the actual public-API conflict, a composite-owner/checkpoint direction, typed compartment and source requirements, worked balances and delivery segments. -It is a concrete design for review, not an implemented adapter or completed 12.5. +The maintainer accepted it on 2026-10-19; [ADR-0172](../adr/0172-cellular-environment-ownership.md) +records the clarified scope and implements the portable joint owner. It is not a +durable profile, live upgrade, producer ecology or completed 12.5. The engineering constitution requires stopping expansion at this architectural boundary and documenting the resolution. That does not prevent the independent diff --git a/docs/engineering/VALIDATION.md b/docs/engineering/VALIDATION.md index 08a672c..13971ca 100644 --- a/docs/engineering/VALIDATION.md +++ b/docs/engineering/VALIDATION.md @@ -1,5 +1,44 @@ # Validation report +## 2026-10-19 - Cellular environment joint owner (M12.5a-b) + +[ADR-0172](../adr/0172-cellular-environment-ownership.md) records the maintainer's +ownership decision and adds envelope `AEVOCEN1`. The joint owner applies each +tick's infall import and radiative heat export to the nested cellular owner as one +validated swap, then runs the unchanged population tick; a refused tick swaps the +exchange back. The only nested change is a private exchange/savepoint pair; no +existing envelope, trace, golden or rule changes meaning. + +Executed locally: + +- GCC 14.2 Release full CTest **94/94, 8.83 s** and MSVC 19.44 Release full CTest + **94/94, 15.16 s**, with NDEBUG. After trimming test tick counts only, the two + environment tests pass **2/2** on both (2.48 s GCC, 3.23 s MSVC). +- Clang 19.1 ASan/UBSan cellular subset **28/28, 200.52 s**, then the trimmed + environment tests **2/2, 66.03 s**, with no sanitizer reports. +- clang-tidy 19 (warnings as errors) on the new owner/tests and the changed + cellular owner/population sources; clang-format 19 on every touched file. +- Fresh-process continuation of a two-source, radiating region (400 + 400 ticks): + MSVC and GCC checkpoint and resumed outputs are byte-identical, SHA-256 + `1746dd489226d612d46624c36987fba83f711c54dfe3f03f3e0bb0be65ea7379`. + +Evidence in the suite: closed and source-off regions keep population bytes +identical to a plain population every tick; a finite entitlement of ten bubbles +per channel is consumed exactly (20 credited, later events counted exhausted and +skipped, nothing more imported); radiated heat (75,000 pJ over 1,500 ticks at a +50 pJ cap) leaves lives, corpses and habitat identical to the closed run; real +wildlife collapsed into an exact cohort matches the individual run through 121 +infall events; a refused tick on an import tick leaves the envelope unchanged and +the retried tick imports. Restore refuses corruption, wrong identity, future +format, import above entitlement, a changed nested length, declared atmosphere, +zero depth, a box unequal to the cellular area or outside its voxel, overlapping +or unsorted sources, stockless or out-of-habitat sources and an owner without a +boundary ledger. Every tick audits `current = opening + incoming - outgoing` and +that environmental flows equal the nested ledger. + +No producer, durable profile, SQL schema, worker integration, target-host cost, +default opening or live upgrade. No World0 operation. + ## 2026-10-19 - Portable retained-plan exact populations [ADR-0171](../adr/0171-retained-plan-exact-populations.md) adds explicit envelope diff --git a/include/evo/server/lifecycle/cellular_environment.hpp b/include/evo/server/lifecycle/cellular_environment.hpp new file mode 100644 index 0000000..55a9707 --- /dev/null +++ b/include/evo/server/lifecycle/cellular_environment.hpp @@ -0,0 +1,141 @@ +#pragma once + +#include "evo/server/lifecycle/cellular_population.hpp" +#include "evo/world/coordinates.hpp" +#include "evo/world/environment_units.hpp" + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace evo::server { +// ADR-0172: one owner of a region's cells and their local environment. +inline constexpr std::uint32_t cellular_environment_format = 1; +inline constexpr std::uint32_t cellular_environment_rules = 1; +inline constexpr std::size_t max_cellular_infall_sources = 4; +// Trial values (ADR-0136 step B): two simulated minutes between events on average, +// 12-24 bubbles per event, dropped within a 1 mm disc. +inline constexpr std::uint64_t cellular_infall_trial_interval_ticks = 2'400; +inline constexpr std::uint32_t cellular_infall_trial_bubbles_min = 12; +inline constexpr std::uint32_t cellular_infall_trial_bubbles_max = 24; +inline constexpr std::uint32_t cellular_infall_clump_radius_um = 500; +inline constexpr std::uint32_t max_cellular_infall_bubbles = 64; +inline constexpr std::size_t cellular_environment_header_bytes = 176; +inline constexpr std::size_t cellular_infall_source_bytes = 208; +inline constexpr std::size_t max_cellular_environment_bytes = + cellular_environment_header_bytes + cellular_infall_source_bytes * max_cellular_infall_sources + + max_cellular_population_bytes + 8; + +// One axis-aligned habitat inside one environmental voxel. Its width and height +// equal the cellular area; depth only defines a sampling volume, never stock. +struct CellularEnvironmentGeometry { + world::VoxelAddress voxel{}; + world::HabitatBox box{}; +}; +// Tagged, inedible compartments. No rules-1 process converts them. +struct CellularWaterColumn { + accounting::Femtograms water{}, dissolved_nitrogen{}, dissolved_phosphorus{}; + auto operator<=>(const CellularWaterColumn&) const = default; +}; +// An audited external import over a declared rectangle and half-open tick interval. +// The entitlement is finite; what remains is entitlement minus imported. +struct CellularInfallSource { + std::uint64_t id{}; + std::uint32_t x_um{}, y_um{}, width_um{}, height_um{}; + std::uint64_t start_tick{}, end_tick{}; + std::uint64_t mean_interval_ticks{cellular_infall_trial_interval_ticks}; + std::uint32_t bubbles_min{cellular_infall_trial_bubbles_min}; + std::uint32_t bubbles_max{cellular_infall_trial_bubbles_max}; + accounting::Inventory per_bubble{}; // Single-channel bubbles cycle stocked channels. + accounting::Inventory entitlement{}; // Cumulative import limit, per channel. + auto operator<=>(const CellularInfallSource&) const = default; +}; +struct CellularInfallProgress { + accounting::Inventory imported{}; + std::uint64_t events{}, credited_bubbles{}, skipped_bubbles{}, exhausted_events{}; + auto operator<=>(const CellularInfallProgress&) const = default; +}; +struct CellularEnvironmentConfig { + CellularEnvironmentGeometry geometry{}; + CellularWaterColumn water{}; + std::vector sources; // Sorted unique ids, disjoint rectangles. + accounting::Picojoules radiation_cap{}; // Heat exported per tick; zero is closed. + std::uint32_t atmosphere_species{}; // Any declared species is unsupported. +}; +struct CellularEnvironmentTickReport { + std::uint64_t tick{}; + accounting::Inventory imported{}; + accounting::Picojoules exported{}; + std::uint64_t events{}, credited_bubbles{}, skipped_bubbles{}; + CellularTickExecution biology; +}; +enum class CellularEnvironmentError : std::uint8_t { + unsupported, + invalid_geometry, + invalid_source, + identity, + habitat, + biology, + overflow, + conservation, + format, + checksum +}; + +class CellularEnvironment { + public: + // Consumes the population on success or failure. + [[nodiscard]] static std::expected, + CellularEnvironmentError> + create(std::unique_ptr population, CellularEnvironmentConfig config); + CellularEnvironment(const CellularEnvironment&) = delete; + CellularEnvironment& operator=(const CellularEnvironment&) = delete; + ~CellularEnvironment(); + + // Read-only views; they confer no separate spending rights. + [[nodiscard]] const CellularPopulation& population() const noexcept; + [[nodiscard]] const CellularLives& state() const noexcept; + [[nodiscard]] const CellularEnvironmentGeometry& geometry() const noexcept; + [[nodiscard]] world::HabitatMeasure measure() const noexcept; + [[nodiscard]] const CellularWaterColumn& water() const noexcept; + [[nodiscard]] std::span sources() const noexcept; + [[nodiscard]] std::span infall() const noexcept; + [[nodiscard]] accounting::Picojoules radiation_cap() const noexcept; + [[nodiscard]] accounting::Inventory imported() const noexcept; // All sources, cumulative. + [[nodiscard]] accounting::Picojoules exported() const noexcept; + [[nodiscard]] std::uint64_t tick() const noexcept; + + // One joint 50 ms tick: the environmental exchange, then the unchanged population + // tick. Any refusal leaves the whole owner byte-for-byte unchanged. + [[nodiscard]] std::expected + advance_tick(std::span controlled, + std::span selections = {}); + // Explicit representation changes of the nested population; no tick advances. + [[nodiscard]] std::expected + collapse(std::uint64_t genome); + [[nodiscard]] std::expected + materialize(std::uint64_t genome); + + [[nodiscard]] std::vector snapshot() const; + [[nodiscard]] static std::expected, + CellularEnvironmentError> + restore(std::span bytes, std::uint64_t world, std::uint64_t region, + std::uint64_t frame, std::uint64_t tick); + + private: + struct Exchange; + CellularEnvironment(std::unique_ptr population, + CellularEnvironmentConfig config); + [[nodiscard]] std::expected + plan_exchange(std::uint64_t tick) const; + std::unique_ptr population_; + CellularEnvironmentConfig config_; + std::vector progress_; // Source order. + accounting::Picojoules exported_{}; +}; +} // namespace evo::server diff --git a/include/evo/server/lifecycle/cellular_lives.hpp b/include/evo/server/lifecycle/cellular_lives.hpp index 5ee2bb0..45c4562 100644 --- a/include/evo/server/lifecycle/cellular_lives.hpp +++ b/include/evo/server/lifecycle/cellular_lives.hpp @@ -139,6 +139,7 @@ struct CellularOffspringRevision { return life.offspring_genome == 0 ? life.identity.genome : life.offspring_genome; } class CellularMigration; +class CellularEnvironment; struct CellularLifeIntent { std::uint64_t life_id{}; biology::CellularStepIntent intent{}; @@ -325,6 +326,19 @@ class CellularLives { private: friend class CellularMigration; + friend class CellularEnvironment; + // ADR-0172: the exchanged-out values, so a refused joint tick can swap them back. + struct BoundarySavepoint { + std::unique_ptr habitat; // Null when no deposit changed. + accounting::Inventory heat{}, current_total{}; + CellularBoundaryLedger boundary{}; + }; + // Validated no-tick exchange: imports the new deposits (ids assigned here) and exports + // retained heat, both through the boundary ledger. Refusal changes nothing. + [[nodiscard]] std::expected + exchange_boundary(std::span deposits, + accounting::Picojoules heat_export); + void restore_boundary(BoundarySavepoint savepoint) noexcept; [[nodiscard]] std::expected, CellularLivesError> migration_replacement(std::vector, const biology::LineageArchive&, CellularBoundaryLedger) const; diff --git a/include/evo/server/lifecycle/cellular_population.hpp b/include/evo/server/lifecycle/cellular_population.hpp index f6f05c6..03056f1 100644 --- a/include/evo/server/lifecycle/cellular_population.hpp +++ b/include/evo/server/lifecycle/cellular_population.hpp @@ -85,6 +85,7 @@ class CellularPopulation { private: friend class CellularMigration; + friend class CellularEnvironment; // ADR-0172: exclusive joint owner of this population. friend std::expected, CellularPopulationError> execute_population_batch(const CellularPopulation&, CellularPopulationBatch&, bool); explicit CellularPopulation(std::unique_ptr state, CellularTierPolicy policy); diff --git a/schemas/cellular-environment-v1.md b/schemas/cellular-environment-v1.md new file mode 100644 index 0000000..41b717a --- /dev/null +++ b/schemas/cellular-environment-v1.md @@ -0,0 +1,46 @@ +# Cellular environment envelope 1 + +Authority: ADR-0172. Little-endian integers, no padding. Size is bounded by +`max_cellular_environment_bytes`. No existing cellular, population, trace or durable +bundle format changes. + +| Offset | Bytes | Field | +|---:|---:|---| +| 0 | 8 | Magic `AEVOCEN1` | +| 8 | 4 | Format 1 | +| 12 | 4 | Environment rules 1 | +| 16 | 8 | World | +| 24 | 8 | Region | +| 32 | 8 | Frame | +| 40 | 8 | Completed tick | +| 48 | 24 | Voxel address x, y, z (two's-complement i64) | +| 72 | 48 | Habitat box x, y, z, width, height, depth in micrometres (u64 each) | +| 120 | 24 | Water, dissolved inorganic N, dissolved inorganic P in femtograms | +| 144 | 8 | Radiation cap, pJ per tick | +| 152 | 8 | Cumulative radiated heat, pJ | +| 160 | 4 | Infall source count, at most 4 | +| 164 | 4 | Reserved, zero | +| 168 | 8 | Nested population envelope bytes | +| 176 | 208 each | Infall sources in strictly increasing id order (below) | +| after sources | declared length | Complete canonical population envelope 2 or 3 | +| final | 8 | FNV-1a64 over all preceding bytes | + +Each source record: id (8); rectangle x, y, width, height (4 each); start and end +tick (8 each, half-open); mean interval ticks (8); bubbles min and max (4 each); +per-bubble inventory, entitlement and cumulative imported inventory (40 each: +energy then C, N, P, other); events, credited bubbles, skipped bubbles and +exhausted events (8 each). + +Restore requires exact length, matching trusted identity and tick, a canonical +nested population whose owner has a boundary ledger (format 7 with rules 8/9, or +format 8 with rules 10), the box inside one voxel with width and height equal to the +cellular area and positive depth, valid disjoint sources, cumulative import within +entitlement, environmental imports within the nested ledger's incoming flow and +radiated heat within its outgoing energy, and byte-identical re-encoding. Atmospheric +species have no field: a configuration declaring any is refused. + +Remaining entitlement and every infall event are derived, never stored: replay +re-derives events from world, region, source id and tick. The checksum detects +corruption only; durable publication must bind SHA-256, predecessor, fence and +manifest. No checkpoint profile, SQL schema or durable bundle admits this envelope +yet, and a nested population restored alone must not publish a joint result. diff --git a/src/server/lifecycle/cellular_environment.cpp b/src/server/lifecycle/cellular_environment.cpp new file mode 100644 index 0000000..0bf5f86 --- /dev/null +++ b/src/server/lifecycle/cellular_environment.cpp @@ -0,0 +1,460 @@ +#include "evo/server/lifecycle/cellular_environment.hpp" + +#include "evo/core/random.hpp" + +#include +#include +#include +#include + +namespace evo::server { +namespace { +constexpr std::uint64_t magic = 0x314E45434F564541ULL; // "AEVOCEN1" +constexpr std::uint64_t infall_stream = 0x494E46414C4CULL; // "INFALL" + +std::uint64_t checksum(std::span bytes) { + std::uint64_t hash = 14695981039346656037ULL; + for (const auto byte : bytes) + hash = (hash ^ byte) * 1099511628211ULL; + return hash; // Corruption detection; trusted publication must also bind SHA-256. +} +void put(std::vector& bytes, std::uint64_t value, unsigned width) { + for (unsigned i = 0; i < width; ++i) { + bytes.push_back(static_cast(value & 255U)); + value >>= 8U; + } +} +void put(std::vector& bytes, const accounting::Inventory& value) { + put(bytes, value.energy.value, 8); + for (const auto& channel : value.matter) + put(bytes, channel.value, 8); +} +class Reader { + public: + explicit Reader(std::span bytes) : bytes_(bytes) {} + std::uint64_t get(unsigned width) { + std::uint64_t value = 0; + for (unsigned i = 0; i < width; ++i) + value |= std::uint64_t{bytes_[at_++]} << (8U * i); + return value; + } + accounting::Inventory inventory() { + accounting::Inventory value; + value.energy.value = get(8); + for (auto& channel : value.matter) + channel.value = get(8); + return value; + } + [[nodiscard]] std::size_t at() const noexcept { + return at_; + } + + private: + std::span bytes_; + std::size_t at_{}; +}; + +// Channel 0 is energy; 1..4 are C, N, P and organic other. +std::uint64_t& channel(accounting::Inventory& value, std::size_t index) noexcept { + return index == 0 ? value.energy.value : value.matter[index - 1].value; +} +std::uint64_t channel(const accounting::Inventory& value, std::size_t index) noexcept { + return index == 0 ? value.energy.value : value.matter[index - 1].value; +} +bool add(accounting::Inventory& total, const accounting::Inventory& value) noexcept { + for (std::size_t index = 0; index < 5; ++index) { + if (channel(value, index) > + std::numeric_limits::max() - channel(total, index)) + return false; + channel(total, index) += channel(value, index); + } + return true; +} +bool within(const accounting::Inventory& part, const accounting::Inventory& whole) noexcept { + for (std::size_t index = 0; index < 5; ++index) + if (channel(part, index) > channel(whole, index)) + return false; + return true; +} +std::uint64_t roll(std::uint64_t world, std::uint64_t region, std::uint64_t source, + std::uint64_t tick) noexcept { + std::uint64_t value = world; + for (const auto salt : {region, source, tick}) { + Random random{value}; + value = random.next() ^ salt; + } + Random random{value}; + return random.next(); +} +bool overlaps(const CellularInfallSource& a, const CellularInfallSource& b) noexcept { + return std::uint64_t{a.x_um} < std::uint64_t{b.x_um} + b.width_um && + std::uint64_t{b.x_um} < std::uint64_t{a.x_um} + a.width_um && + std::uint64_t{a.y_um} < std::uint64_t{b.y_um} + b.height_um && + std::uint64_t{b.y_um} < std::uint64_t{a.y_um} + a.height_um; +} +bool supported(const CellularLives& state) noexcept { + return (state.format_version() == cellular_lives_migration_format && + (state.rules_version() == cellular_lives_foraging_rules || + state.rules_version() == cellular_lives_maturation_rules)) || + (state.format_version() == cellular_lives_inheritance_format && + state.rules_version() == cellular_lives_inheritance_rules); +} +std::expected +validate(const CellularLives& state, const CellularEnvironmentConfig& config) { + if (!supported(state)) + return std::unexpected(CellularEnvironmentError::unsupported); + if (config.atmosphere_species != 0) + return std::unexpected(CellularEnvironmentError::unsupported); + const auto& box = config.geometry.box; + const auto measure = world::measure_habitat(box); + if (!measure || box.width.value != state.area().width_um || + box.height.value != state.area().height_um || box.depth.value == 0) + return std::unexpected(CellularEnvironmentError::invalid_geometry); + if (config.sources.size() > max_cellular_infall_sources) + return std::unexpected(CellularEnvironmentError::invalid_source); + for (std::size_t index = 0; index < config.sources.size(); ++index) { + const auto& source = config.sources[index]; + const bool stocked = source.per_bubble != accounting::Inventory{}; + if (source.id == 0 || (index != 0 && config.sources[index - 1].id >= source.id) || + source.width_um == 0 || source.height_um == 0 || + std::uint64_t{source.x_um} + source.width_um > state.area().width_um || + std::uint64_t{source.y_um} + source.height_um > state.area().height_um || + source.start_tick >= source.end_tick || source.mean_interval_ticks == 0 || + source.bubbles_min == 0 || source.bubbles_min > source.bubbles_max || + source.bubbles_max > max_cellular_infall_bubbles || !stocked) + return std::unexpected(CellularEnvironmentError::invalid_source); + for (std::size_t other = 0; other < index; ++other) + if (overlaps(config.sources[other], source)) + return std::unexpected(CellularEnvironmentError::invalid_source); + } + return *measure; +} +} // namespace + +struct CellularEnvironment::Exchange { + std::vector deposits; + accounting::Picojoules heat_export{}; + std::vector progress; + CellularEnvironmentTickReport report; +}; + +CellularEnvironment::CellularEnvironment(std::unique_ptr population, + CellularEnvironmentConfig config) + : population_(std::move(population)), config_(std::move(config)), + progress_(config_.sources.size()) {} +CellularEnvironment::~CellularEnvironment() = default; + +std::expected, CellularEnvironmentError> +CellularEnvironment::create(std::unique_ptr population, + CellularEnvironmentConfig config) { + if (!population) + return std::unexpected(CellularEnvironmentError::unsupported); + const auto measure = validate(population->state(), config); + if (!measure) + return std::unexpected(measure.error()); + return std::unique_ptr( + new CellularEnvironment(std::move(population), std::move(config))); +} + +const CellularPopulation& CellularEnvironment::population() const noexcept { + return *population_; +} +const CellularLives& CellularEnvironment::state() const noexcept { + return population_->state(); +} +const CellularEnvironmentGeometry& CellularEnvironment::geometry() const noexcept { + return config_.geometry; +} +world::HabitatMeasure CellularEnvironment::measure() const noexcept { + // Validated at creation and restore; the box never changes. + const auto& box = config_.geometry.box; + return {{box.width.value * box.height.value}, + {box.width.value * box.height.value * box.depth.value}}; +} +const CellularWaterColumn& CellularEnvironment::water() const noexcept { + return config_.water; +} +std::span CellularEnvironment::sources() const noexcept { + return config_.sources; +} +std::span CellularEnvironment::infall() const noexcept { + return progress_; +} +accounting::Picojoules CellularEnvironment::radiation_cap() const noexcept { + return config_.radiation_cap; +} +accounting::Inventory CellularEnvironment::imported() const noexcept { + accounting::Inventory total; + for (const auto& source : progress_) + static_cast(add(total, source.imported)); // Bounded by the nested ledger. + return total; +} +accounting::Picojoules CellularEnvironment::exported() const noexcept { + return exported_; +} +std::uint64_t CellularEnvironment::tick() const noexcept { + return population_->state().tick(); +} + +std::expected +CellularEnvironment::plan_exchange(std::uint64_t tick) const { + const auto& state = population_->state(); + const auto& habitat = state.habitat(); + const auto area = state.area(); + Exchange exchange; + exchange.progress = progress_; + exchange.report.tick = tick; + std::set taken; + for (std::size_t index = 0; index < config_.sources.size(); ++index) { + const auto& source = config_.sources[index]; + auto& progress = exchange.progress[index]; + if (tick < source.start_tick || tick >= source.end_tick) + continue; + const auto event = roll(state.world(), state.region(), source.id, tick); + if (event % source.mean_interval_ticks != 0) + continue; + Random stream{event ^ infall_stream}; + const auto count = + source.bubbles_min + static_cast( + stream.next() % (source.bubbles_max - source.bubbles_min + 1)); + const auto centre_x = + source.x_um + static_cast(stream.next() % source.width_um); + const auto centre_y = + source.y_um + static_cast(stream.next() % source.height_um); + std::vector stocked; + for (std::size_t slot = 0; slot < 5; ++slot) + if (channel(source.per_bubble, slot) != 0) + stocked.push_back(slot); + const auto first = static_cast(stream.next() % stocked.size()); + bool remaining = false; + for (const auto slot : stocked) + remaining = + remaining || channel(progress.imported, slot) < channel(source.entitlement, slot); + ++progress.events; + ++exchange.report.events; + if (!remaining) + ++progress.exhausted_events; + for (std::uint32_t bubble = 0; bubble < count; ++bubble) { + const auto slot = stocked[(first + bubble) % stocked.size()]; + constexpr auto radius = std::int64_t{cellular_infall_clump_radius_um}; + std::int64_t dx = 0, dy = 0; + for (unsigned attempt = 0; attempt < 8; ++attempt) { + const auto x = static_cast(stream.next() % (2 * radius + 1)) - radius; + const auto y = static_cast(stream.next() % (2 * radius + 1)) - radius; + if (x * x + y * y <= radius * radius) { + dx = x; + dy = y; + break; + } + } + const biology::CellularPatchAddress address{ + static_cast(std::clamp( + std::int64_t{centre_x} + dx, 0, static_cast(area.width_um) - 1)), + static_cast( + std::clamp(std::int64_t{centre_y} + dy, 0, + static_cast(area.height_um) - 1))}; + const auto left = channel(source.entitlement, slot) - channel(progress.imported, slot); + const auto amount = std::min(channel(source.per_bubble, slot), left); + if (amount == 0 || habitat.find(address) || taken.contains(address) || + habitat.patches().size() + exchange.deposits.size() >= + biology::max_cellular_patches) { + ++progress.skipped_bubbles; + ++exchange.report.skipped_bubbles; + continue; + } + biology::CellularPatch deposit; + deposit.address = address; + deposit.source = source.id; + deposit.radius_um = biology::cellular_mote_radius_um; + deposit.kind = biology::CellularDepositKind::mote; + channel(deposit.stock, slot) = amount; + if (!add(progress.imported, deposit.stock) || + !add(exchange.report.imported, deposit.stock)) + return std::unexpected(CellularEnvironmentError::overflow); + taken.insert(address); + exchange.deposits.push_back(deposit); + ++progress.credited_bubbles; + ++exchange.report.credited_bubbles; + } + } + exchange.heat_export.value = std::min(state.heat().energy.value, config_.radiation_cap.value); + if (exchange.heat_export.value > std::numeric_limits::max() - exported_.value) + return std::unexpected(CellularEnvironmentError::overflow); + exchange.report.exported = exchange.heat_export; + return exchange; +} + +std::expected +CellularEnvironment::advance_tick(std::span controlled, + std::span selections) { + if (tick() == std::numeric_limits::max()) + return std::unexpected(CellularEnvironmentError::overflow); + auto exchange = plan_exchange(tick() + 1); + if (!exchange) + return std::unexpected(exchange.error()); + auto& lives = *population_->state_; + auto savepoint = lives.exchange_boundary(exchange->deposits, exchange->heat_export); + if (!savepoint) + return std::unexpected(savepoint.error() == CellularLivesError::habitat + ? CellularEnvironmentError::habitat + : CellularEnvironmentError::conservation); + auto executed = population_->advance_tick(controlled, selections); + if (!executed) { + lives.restore_boundary(std::move(*savepoint)); + return std::unexpected(CellularEnvironmentError::biology); + } + progress_ = std::move(exchange->progress); + exported_.value += exchange->heat_export.value; + exchange->report.biology = std::move(*executed); + return std::move(exchange->report); +} + +std::expected +CellularEnvironment::collapse(std::uint64_t genome) { + const auto converted = population_->collapse(genome); + if (!converted) + return std::unexpected(CellularEnvironmentError::biology); + return *converted; +} +std::expected +CellularEnvironment::materialize(std::uint64_t genome) { + const auto converted = population_->materialize(genome); + if (!converted) + return std::unexpected(CellularEnvironmentError::biology); + return *converted; +} + +std::vector CellularEnvironment::snapshot() const { + const auto nested = population_->snapshot(); + const auto& state = population_->state(); + const auto& geometry = config_.geometry; + std::vector bytes; + bytes.reserve(cellular_environment_header_bytes + + cellular_infall_source_bytes * config_.sources.size() + nested.size() + 8); + put(bytes, magic, 8); + put(bytes, cellular_environment_format, 4); + put(bytes, cellular_environment_rules, 4); + for (const auto value : + {state.world(), state.region(), state.frame(), state.tick(), + static_cast(geometry.voxel.x), + static_cast(geometry.voxel.y), + static_cast(geometry.voxel.z), geometry.box.x.value, geometry.box.y.value, + geometry.box.z.value, geometry.box.width.value, geometry.box.height.value, + geometry.box.depth.value, config_.water.water.value, + config_.water.dissolved_nitrogen.value, config_.water.dissolved_phosphorus.value, + config_.radiation_cap.value, exported_.value}) + put(bytes, value, 8); + put(bytes, config_.sources.size(), 4); + put(bytes, 0, 4); + put(bytes, nested.size(), 8); + for (std::size_t index = 0; index < config_.sources.size(); ++index) { + const auto& source = config_.sources[index]; + const auto& progress = progress_[index]; + put(bytes, source.id, 8); + for (const auto value : {source.x_um, source.y_um, source.width_um, source.height_um}) + put(bytes, value, 4); + put(bytes, source.start_tick, 8); + put(bytes, source.end_tick, 8); + put(bytes, source.mean_interval_ticks, 8); + put(bytes, source.bubbles_min, 4); + put(bytes, source.bubbles_max, 4); + put(bytes, source.per_bubble); + put(bytes, source.entitlement); + put(bytes, progress.imported); + for (const auto value : {progress.events, progress.credited_bubbles, + progress.skipped_bubbles, progress.exhausted_events}) + put(bytes, value, 8); + } + bytes.insert(bytes.end(), nested.begin(), nested.end()); + put(bytes, checksum(bytes), 8); + return bytes; +} + +std::expected, CellularEnvironmentError> +CellularEnvironment::restore(std::span bytes, std::uint64_t world, + std::uint64_t region, std::uint64_t frame, std::uint64_t tick) { + if (bytes.size() < cellular_environment_header_bytes + 8 || + bytes.size() > max_cellular_environment_bytes) + return std::unexpected(CellularEnvironmentError::format); + Reader tail(bytes.last(8)); + if (tail.get(8) != checksum(bytes.first(bytes.size() - 8))) + return std::unexpected(CellularEnvironmentError::checksum); + Reader in(bytes); + if (in.get(8) != magic) + return std::unexpected(CellularEnvironmentError::format); + if (in.get(4) != cellular_environment_format || in.get(4) != cellular_environment_rules) + return std::unexpected(CellularEnvironmentError::unsupported); + if (in.get(8) != world || in.get(8) != region || in.get(8) != frame || in.get(8) != tick) + return std::unexpected(CellularEnvironmentError::identity); + CellularEnvironmentConfig config; + config.geometry.voxel = {static_cast(in.get(8)), + static_cast(in.get(8)), + static_cast(in.get(8))}; + auto& box = config.geometry.box; + box.x.value = in.get(8); + box.y.value = in.get(8); + box.z.value = in.get(8); + box.width.value = in.get(8); + box.height.value = in.get(8); + box.depth.value = in.get(8); + config.water.water.value = in.get(8); + config.water.dissolved_nitrogen.value = in.get(8); + config.water.dissolved_phosphorus.value = in.get(8); + config.radiation_cap.value = in.get(8); + const accounting::Picojoules exported{in.get(8)}; + const auto count = in.get(4); + if (in.get(4) != 0 || count > max_cellular_infall_sources) + return std::unexpected(CellularEnvironmentError::format); + const auto nested_bytes = in.get(8); + if (nested_bytes == 0 || nested_bytes > max_cellular_population_bytes || + bytes.size() != cellular_environment_header_bytes + count * cellular_infall_source_bytes + + nested_bytes + 8) + return std::unexpected(CellularEnvironmentError::format); + std::vector progress; + for (std::uint64_t index = 0; index < count; ++index) { + CellularInfallSource source; + source.id = in.get(8); + source.x_um = static_cast(in.get(4)); + source.y_um = static_cast(in.get(4)); + source.width_um = static_cast(in.get(4)); + source.height_um = static_cast(in.get(4)); + source.start_tick = in.get(8); + source.end_tick = in.get(8); + source.mean_interval_ticks = in.get(8); + source.bubbles_min = static_cast(in.get(4)); + source.bubbles_max = static_cast(in.get(4)); + source.per_bubble = in.inventory(); + source.entitlement = in.inventory(); + CellularInfallProgress done; + done.imported = in.inventory(); + done.events = in.get(8); + done.credited_bubbles = in.get(8); + done.skipped_bubbles = in.get(8); + done.exhausted_events = in.get(8); + if (!within(done.imported, source.entitlement)) + return std::unexpected(CellularEnvironmentError::conservation); + config.sources.push_back(source); + progress.push_back(done); + } + auto population = CellularPopulation::restore( + bytes.subspan(in.at(), static_cast(nested_bytes)), world, region, frame, tick); + if (!population) + return std::unexpected(CellularEnvironmentError::format); + auto candidate = create(std::move(*population), std::move(config)); + if (!candidate) + return std::unexpected(candidate.error()); + (*candidate)->progress_ = std::move(progress); + (*candidate)->exported_ = exported; + // Environmental flows are part of the nested ledger, never in addition to it. + accounting::Inventory flows; + for (const auto& done : (*candidate)->progress_) + if (!add(flows, done.imported)) + return std::unexpected(CellularEnvironmentError::conservation); + const auto& ledger = (*candidate)->state().boundary_ledger(); + if (!within(flows, ledger.incoming) || exported.value > ledger.outgoing.energy.value) + return std::unexpected(CellularEnvironmentError::conservation); + if (!std::ranges::equal((*candidate)->snapshot(), bytes)) + return std::unexpected(CellularEnvironmentError::format); + return candidate; +} +} // namespace evo::server diff --git a/src/server/lifecycle/cellular_lives.cpp b/src/server/lifecycle/cellular_lives.cpp index f028364..e1781df 100644 --- a/src/server/lifecycle/cellular_lives.cpp +++ b/src/server/lifecycle/cellular_lives.cpp @@ -800,6 +800,77 @@ CellularLives::migration_replacement(std::vector living, return replacement; } +std::expected +CellularLives::exchange_boundary(std::span deposits, + accounting::Picojoules heat_export) { + if (state_->format_version != cellular_lives_migration_format && + state_->format_version != cellular_lives_inheritance_format) + return std::unexpected(CellularLivesError::version); + if (heat_export.value > state_->heat.energy.value) + return std::unexpected(CellularLivesError::conservation); + auto boundary = state_->boundary; + auto heat = state_->heat; + heat.energy.value -= heat_export.value; + if (heat_export.value > + std::numeric_limits::max() - boundary.outgoing.energy.value) + return std::unexpected(CellularLivesError::overflow); + boundary.outgoing.energy.value += heat_export.value; + if (deposits.empty()) { + // Heat alone: the total falls by exactly the recorded export, so closure holds. + BoundarySavepoint savepoint{nullptr, state_->heat, state_->current_total, state_->boundary}; + state_->heat = heat; + state_->current_total.energy.value -= heat_export.value; + state_->boundary = std::move(boundary); + return savepoint; + } + std::unique_ptr habitat; + { + auto config = state_->habitat->config(); + if (config.format != biology::cellular_habitat_deposit_format) + return std::unexpected(CellularLivesError::version); + for (auto deposit : deposits) { + if (config.next_deposit == std::numeric_limits::max() || + deposit.stock == accounting::Inventory{} || + !add_inventory(boundary.incoming, deposit.stock)) + return std::unexpected(CellularLivesError::overflow); + deposit.id = config.next_deposit++; + const auto at = std::ranges::lower_bound(config.patches, deposit.address, {}, + &biology::CellularPatch::address); + if (at != config.patches.end() && at->address == deposit.address) + return std::unexpected(CellularLivesError::habitat); + config.patches.insert(at, deposit); + } + auto created = biology::CellularHabitat::create(std::move(config)); + if (!created) + return std::unexpected(CellularLivesError::habitat); + habitat = std::move(*created); + } + const auto rules = state_->rules_version; + const auto total = validate_state( + state_->world, state_->region, state_->frame, state_->config, state_->nursery_config, + *habitat, state_->lives, state_->corpses, state_->archive, state_->nursery, heat, + state_->opening_total, rules >= cellular_lives_engulf_rules, + rules >= cellular_lives_bud_rules, state_->next_bud_sequence, + rules >= cellular_lives_presence_rules, &boundary, + rules == cellular_lives_inheritance_rules ? &state_->offspring_revisions : nullptr); + if (!total) + return std::unexpected(total.error()); + BoundarySavepoint savepoint{std::move(state_->habitat), state_->heat, state_->current_total, + state_->boundary}; + state_->habitat = std::move(habitat); + state_->heat = heat; + state_->current_total = *total; + state_->boundary = std::move(boundary); + return savepoint; +} +void CellularLives::restore_boundary(BoundarySavepoint savepoint) noexcept { + if (savepoint.habitat) + state_->habitat = std::move(savepoint.habitat); + state_->heat = savepoint.heat; + state_->current_total = savepoint.current_total; + state_->boundary = std::move(savepoint.boundary); +} + std::expected, CellularLivesError> CellularLives::migration_upgrade_candidate() const { if (state_->rules_version != cellular_lives_foraging_rules) diff --git a/tests/cellular_environment_tests.cpp b/tests/cellular_environment_tests.cpp new file mode 100644 index 0000000..cc1826c --- /dev/null +++ b/tests/cellular_environment_tests.cpp @@ -0,0 +1,387 @@ +#include "evo/server/lifecycle/cellular_environment.hpp" +#include "fixtures/cellular_ecology.hpp" + +#include +#include +#include + +namespace { +using namespace evo; +using namespace evo::server; +using namespace evo::fixture; +using Environment = std::unique_ptr; + +std::vector controlled(const CellularLives& state, bool bud = false) { + std::vector result; + for (const auto& life : state.lives()) + if (life.account != LifeAccount{}) { + CellularLifeIntent input{life.identity.life, {}}; + input.intent.bud = bud; + result.push_back(input); + } + return result; +} +// A real rules-9/owner-7 region: four funded founders on finite contact food. +Owner founders(std::uint64_t seed = 7) { + auto state = opening(seed, true); + state = checked(state->migration_upgrade_candidate(), "boundary upgrade"); + return checked(state->maturation_upgrade_candidate(), "maturation upgrade"); +} +Inventory energy_and_carbon(std::uint64_t energy, std::uint64_t carbon) { + Inventory value{{energy}, {}}; + value.matter[0].value = carbon; + return value; +} +CellularInfallSource source(std::uint64_t id, std::uint32_t x, std::uint64_t interval, + Inventory entitlement, std::uint64_t start = 1, + std::uint64_t end = std::numeric_limits::max()) { + CellularInfallSource made; + made.id = id; + made.x_um = x; + made.y_um = 0; + made.width_um = 3'000; + made.height_um = 6'000; + made.start_tick = start; + made.end_tick = end; + made.mean_interval_ticks = interval; + made.per_bubble = energy_and_carbon(400'000, 40'000); + made.entitlement = entitlement; + return made; +} +CellularEnvironmentConfig config(std::vector sources = {}, + std::uint64_t radiation = 0) { + CellularEnvironmentConfig made; + made.geometry.voxel = {3, -2, 5}; + made.geometry.box = {{1'000}, {2'000}, {0}, {6'000}, {6'000}, {10}}; + made.water = {{5'000'000}, {70'000}, {9'000}}; + made.sources = std::move(sources); + made.radiation_cap = {radiation}; + return made; +} +Environment environment(Owner state, CellularEnvironmentConfig made) { + auto population = + checked(CellularPopulation::create(std::move(state), {false, 900, 1'600}), "population"); + return checked(CellularEnvironment::create(std::move(population), std::move(made)), + "environment"); +} +Environment copy(const CellularEnvironment& value) { + return checked(CellularEnvironment::restore(value.snapshot(), value.state().world(), + value.state().region(), value.state().frame(), + value.tick()), + "environment copy"); +} +void step(CellularEnvironment& value, bool bud = false) { + checked(value.advance_tick(controlled(value.state(), bud)), "joint tick"); +} +// Every channel: current == opening + incoming - outgoing, and the environment's own +// flows are the complete ledger here (no migration). +void audit(const CellularEnvironment& value) { + const auto& state = value.state(); + const auto& ledger = state.boundary_ledger(); + auto expected = state.opening_total(); + expected.energy.value += ledger.incoming.energy.value; + expected.energy.value -= ledger.outgoing.energy.value; + for (std::size_t channel = 0; channel < expected.matter.size(); ++channel) + expected.matter[channel].value += + ledger.incoming.matter[channel].value - ledger.outgoing.matter[channel].value; + require(state.current_total() == expected, "joint owner broke open-boundary closure"); + require(ledger.incoming == value.imported() && + ledger.outgoing == Inventory{value.exported(), {}}, + "environment flows differ from the nested boundary ledger"); + for (std::size_t index = 0; index < value.sources().size(); ++index) { + const auto& made = value.sources()[index]; + const auto& done = value.infall()[index]; + require(done.imported.energy <= made.entitlement.energy && + done.imported.matter[0] <= made.entitlement.matter[0], + "infall exceeded its entitlement"); + } + require(value.water() == CellularWaterColumn{{5'000'000}, {70'000}, {9'000}}, + "rules 1 changed tagged water or dissolved nutrients"); +} + +// Source-off and closed regions keep the original biology exactly; a plain population +// advanced without the composite agrees byte for byte. +void closed_and_source_off() { + auto closed = environment(founders(), config()); + const auto next = founders()->tick() + 1; + auto off = environment( + founders(), config({source(1, 0, 1, energy_and_carbon(1 << 30, 1 << 30), next, next + 1)})); + auto plain = + checked(CellularPopulation::create(founders(), {false, 900, 1'600}), "plain population"); + // Tick 1 is inside the off source's interval; advance past it first without events. + for (unsigned tick = 0; tick < 1'000; ++tick) { + step(*closed, tick % 100 == 0); + if (tick == 0) { + const auto report = off->advance_tick(controlled(off->state(), true)); + require(report && report->events == 1 && report->credited_bubbles > 0, + "every-tick source missed its only active tick"); + } else { + step(*off, tick % 100 == 0); + } + checked(plain->advance_tick(controlled(plain->state(), tick % 100 == 0)), "plain tick"); + audit(*closed); + audit(*off); + require(closed->population().snapshot() == plain->snapshot(), + "closed joint owner changed biology"); + } + require(closed->imported() == Inventory{} && closed->exported().value == 0 && + closed->state().current_total() == closed->state().opening_total(), + "closed region crossed its boundary"); + require(off->infall()[0].events == 1 && off->imported() != Inventory{} && + off->state().current_total() != off->state().opening_total(), + "source interval did not end after one tick"); +} + +// Open infall exhausts a finite entitlement exactly, then imports nothing. +void exhaustion() { + const auto entitlement = energy_and_carbon(4'000'000, 400'000); // Ten bubbles each. + auto open = environment(founders(), config({source(1, 0, 40, entitlement)})); + std::uint64_t exhausted_at = 0; + for (unsigned tick = 0; tick < 2'000; ++tick) { + step(*open, tick % 100 == 0); + audit(*open); + if (exhausted_at == 0 && open->imported() == entitlement) + exhausted_at = open->tick(); + } + const auto& done = open->infall()[0]; + require(exhausted_at != 0 && open->imported() == entitlement && done.exhausted_events > 0 && + done.credited_bubbles == 20 && done.skipped_bubbles > 0, + "finite infall entitlement was not consumed exactly once"); + std::cout << "exhaustion: entitlement consumed at tick " << exhausted_at << ", events " + << done.events << ", credited " << done.credited_bubbles << ", skipped " + << done.skipped_bubbles << ", exhausted events " << done.exhausted_events << '\n'; + const auto after = open->imported(); + for (unsigned tick = 0; tick < 500; ++tick) + step(*open); + require(open->imported() == after, "exhausted source imported more stock"); +} + +// Radiative export removes retained heat only: biology is unchanged against closed. +void radiation() { + auto closed = environment(founders(), config()); + auto radiating = environment(founders(), config({}, 50)); + for (unsigned tick = 0; tick < 1'500; ++tick) { + step(*closed, tick % 100 == 0); + step(*radiating, tick % 100 == 0); + audit(*radiating); + const auto& a = closed->state(); + const auto& b = radiating->state(); + require(std::ranges::equal(a.lives(), b.lives()) && + std::ranges::equal(a.corpses(), b.corpses()) && + a.habitat().snapshot() == b.habitat().snapshot() && + a.heat().energy.value == b.heat().energy.value + radiating->exported().value, + "radiated heat changed biology or was not removed exactly"); + } + require(radiating->exported().value > 0, "no heat was radiated"); + std::cout << "radiation: exported " << radiating->exported().value << " pJ, retained " + << radiating->state().heat().energy.value << " of " + << closed->state().heat().energy.value << " pJ closed\n"; +} + +// A refused tick on an infall tick changes nothing; restore continues exactly. +void atomic_and_restore() { + // Every tick of the first 25 imports, so the refused tick carries an exchange. + const auto next = founders()->tick() + 1; + auto value = environment( + founders(), + config({source(1, 0, 1, energy_and_carbon(1 << 30, 1 << 30), next, next + 25)}, 7)); + for (unsigned tick = 0; tick < 20; ++tick) + step(*value); + const auto before = value->snapshot(); + const auto patches = value->state().habitat().patches().size(); + require(!value->advance_tick({}).has_value() && value->snapshot() == before && + value->state().habitat().patches().size() == patches, + "refused joint tick kept a torn exchange"); + auto restored = copy(*value); + require(restored->snapshot() == before, "restore changed the joint envelope"); + const auto retried = checked(value->advance_tick(controlled(value->state())), "retried tick"); + require(retried.credited_bubbles > 0 && retried.imported != Inventory{}, + "the refused tick carried no exchange"); + step(*restored); + require(value->snapshot() == restored->snapshot(), "retry differed from the restored owner"); + for (unsigned tick = 0; tick < 200; ++tick) { + step(*value, tick % 50 == 0); + step(*restored, tick % 50 == 0); + require(value->snapshot() == restored->snapshot(), "restored owner diverged"); + } + audit(*restored); +} + +// Exact cohorts of real wildlife see the same environment and biology as individuals. +void raw_and_cohort() { + auto raw = environment( + founders(), config({source(1, 0, 60, energy_and_carbon(1ULL << 40, 1ULL << 40))}, 20)); + std::uint64_t genome = 0; + for (unsigned tick = 0; tick < 30'000 && genome == 0; ++tick) { + step(*raw, true); + for (const auto& life : raw->state().lives()) + if (life.account == LifeAccount{}) + genome = life.identity.genome; + } + require(genome != 0, "no real wildlife for cohort comparison"); + auto cohort = copy(*raw); + require(checked(cohort->collapse(genome), "collapse wildlife") > 0, "empty cohort"); + for (unsigned tick = 0; tick < 1'500; ++tick) { + const auto a = checked(raw->advance_tick(controlled(raw->state(), tick % 40 == 0)), "raw"); + const auto b = + checked(cohort->advance_tick(controlled(cohort->state(), tick % 40 == 0)), "cohort"); + require(a.imported == b.imported && a.exported == b.exported && + a.biology.buds == b.biology.buds && + raw->state().snapshot() == cohort->state().snapshot(), + "cohort and individual representations diverged"); + } + audit(*cohort); + require(raw->infall()[0].events > 0, "comparison saw no infall"); + std::cout << "raw/cohort: " << cohort->population().members().size() << " tagged of " + << raw->state().lives().size() << " lives, infall events " << raw->infall()[0].events + << ", imported energy " << raw->imported().energy.value << " pJ, radiated " + << raw->exported().value << " pJ at tick " << raw->tick() << '\n'; +} + +std::vector resealed(std::vector bytes) { + std::uint64_t hash = 14695981039346656037ULL; + for (std::size_t i = 0; i + 8 < bytes.size(); ++i) + hash = (hash ^ bytes[i]) * 1099511628211ULL; + for (std::size_t i = 0; i < 8; ++i) + bytes[bytes.size() - 8 + i] = static_cast(hash >> (8U * i)); + return bytes; +} +void refusals() { + auto value = environment(founders(), config({source(1, 0, 1, energy_and_carbon(800'000, 1))})); + for (unsigned tick = 0; tick < 5; ++tick) + step(*value); + const auto bytes = value->snapshot(); + const auto world = value->state().world(), region = value->state().region(), + frame = value->state().frame(), tick = value->tick(); + auto corrupt = bytes; + corrupt[200] ^= 1U; + require(CellularEnvironment::restore(corrupt, world, region, frame, tick).error() == + CellularEnvironmentError::checksum, + "corruption accepted"); + require(CellularEnvironment::restore(bytes, world, region, frame, tick + 1).error() == + CellularEnvironmentError::identity, + "wrong tick accepted"); + auto version = bytes; + version[8] = 2; + require(CellularEnvironment::restore(resealed(version), world, region, frame, tick).error() == + CellularEnvironmentError::unsupported, + "future envelope accepted"); + // The first source's cumulative energy import (after id, rect, ticks, interval, + // bubble bounds, per-bubble and entitlement) above its entitlement. + auto excess = bytes; + const auto imported = cellular_environment_header_bytes + 8 + 16 + 24 + 8 + 40 + 40; + excess[imported + 7] = 0x7F; + require(CellularEnvironment::restore(resealed(excess), world, region, frame, tick).error() == + CellularEnvironmentError::conservation, + "import above entitlement accepted"); + auto nested = bytes; + nested[cellular_environment_header_bytes - 8] ^= 1U; // Nested length. + require(!CellularEnvironment::restore(resealed(nested), world, region, frame, tick), + "nested length accepted"); + + const auto refused = [](CellularEnvironmentConfig made, CellularEnvironmentError error, + Owner state = founders()) { + auto population = checked(CellularPopulation::create(std::move(state), {false, 900, 1'600}), + "refusal population"); + const auto result = CellularEnvironment::create(std::move(population), std::move(made)); + return !result && result.error() == error; + }; + auto atmosphere = config(); + atmosphere.atmosphere_species = 1; + require(refused(atmosphere, CellularEnvironmentError::unsupported), + "atmosphere treated as zero or unlimited"); + auto flat = config(); + flat.geometry.box.depth = {0}; + require(refused(flat, CellularEnvironmentError::invalid_geometry), "zero depth accepted"); + auto camera = config(); + camera.geometry.box.width = {5'000}; + require(refused(camera, CellularEnvironmentError::invalid_geometry), + "box disagreed with the cellular area"); + auto outside = config(); + outside.geometry.box.x = {996'000}; + require(refused(outside, CellularEnvironmentError::invalid_geometry), + "habitat crossed its voxel"); + const auto plenty = energy_and_carbon(1 << 20, 1 << 20); + require(refused(config({source(1, 0, 1, plenty), source(2, 2'000, 1, plenty)}), + CellularEnvironmentError::invalid_source), + "overlapping entitlements accepted"); + require(refused(config({source(2, 0, 1, plenty), source(1, 3'000, 1, plenty)}), + CellularEnvironmentError::invalid_source), + "unsorted sources accepted"); + auto empty = source(1, 0, 1, plenty); + empty.per_bubble = {}; + require(refused(config({empty}), CellularEnvironmentError::invalid_source), + "stockless source accepted"); + require( + refused(config({source(1, 4'000, 1, plenty)}), CellularEnvironmentError::invalid_source), + "source outside the habitat accepted"); + require(refused(config(), CellularEnvironmentError::unsupported, opening(7, true)), + "owner without a boundary ledger accepted"); +} + +constexpr std::uint64_t restart_ticks = 400; +Environment restart_fixture() { + auto value = + environment(founders(), config({source(1, 0, 25, energy_and_carbon(1ULL << 40, 1ULL << 40)), + source(4, 3'000, 30, energy_and_carbon(1ULL << 40, 9))}, + 11)); + for (std::uint64_t tick = 0; tick < restart_ticks; ++tick) + step(*value, tick % 50 == 0); + return value; +} +void write(const char* path, const std::vector& bytes) { + std::ofstream out(path, std::ios::binary); + out.write(reinterpret_cast(bytes.data()), + static_cast(bytes.size())); + require(out.good(), "write failed"); +} +std::vector read(const char* path) { + std::ifstream in(path, std::ios::binary); + return {std::istreambuf_iterator(in), {}}; +} +void continue_fixture(CellularEnvironment& value) { + for (std::uint64_t tick = 0; tick < restart_ticks; ++tick) + step(value, tick % 50 == 0); +} +} // namespace + +int main(int argc, char** argv) { + try { + if (argc == 4 && std::strcmp(argv[1], "--checkpoint") == 0) { + auto value = restart_fixture(); + write(argv[2], value->snapshot()); + continue_fixture(*value); + audit(*value); + write(argv[3], value->snapshot()); + return 0; + } + if (argc == 4 && std::strcmp(argv[1], "--resume") == 0) { + const auto bytes = read(argv[2]); + // Identity is trusted input, never taken from the envelope it checks. + const auto origin = founders(); + auto value = checked(CellularEnvironment::restore(bytes, origin->world(), + origin->region(), origin->frame(), + origin->tick() + restart_ticks), + "fresh-process restore"); + continue_fixture(*value); + write(argv[3], value->snapshot()); + return 0; + } + closed_and_source_off(); + exhaustion(); + radiation(); + atomic_and_restore(); + raw_and_cohort(); + refusals(); + auto value = restart_fixture(); + audit(*value); + require(value->infall()[0].events > 0 && value->infall()[1].events > 0 && + value->exported().value > 0, + "restart fixture crossed no boundary"); + std::cout << "cellular environment contracts passed\n"; + return 0; + } catch (const std::exception& error) { + std::cerr << error.what() << '\n'; + return 1; + } +}