feat: durable liquid regions (bundle 14, schema 58), cellular-v9 and session v13
Foundation / checks (checks) (push) Successful in 5s
Foundation / checks (client) (push) Successful in 5s
Foundation / checks (ecs) (push) Successful in 4s
Foundation / checks (network) (push) Successful in 4s
Foundation / checks (postgres) (push) Successful in 4s
Foundation / checks (tsan) (push) Successful in 5s
Foundation / checks (deploy) (push) Successful in 4m25s
Foundation / postgres-tools (push) Successful in 1m12s
Foundation / server-image (push) Successful in 4m20s
Foundation / image (push) Successful in 4m54s

ADR-0178. Bundle 14 (rules 12 on owner format 10) is admitted by schema 58
through parser-local normalization to bundle 13, with an exact fenced 13 -> 14
upgrade whose only input, the liquid rules, recovery reads from the target.
Schema 58 also widens the canonical action input: byte 13 bit 0 is brake.

evo-world-clone gains the cellular-v9 opening: cellular-v8 followed by the liquid
upgrade from --tuning FILE (region size must match) and an optional
--current-seed; resumable and idempotent at bundle 14.

Session v13 adds the owner's velocity, heading and the region's current
configuration to its perception, each deposit's world velocity, and a brake on
cellular actions; older sessions keep their layouts. A rules-12 server lists every
pool and the nearest 256 moving bubbles. The client speaks v13, brakes on Space
(rebindable; older controls files take the default), draws currents as drifting
streaks and carries bubbles along their velocities between perceptions.

Tests: protocol v13 round trips and refusals, action-input brake, controls files,
and a PostgreSQL cellular-v9 provisioning test whose player is born, swims and
brakes through the live host. Full local PostgreSQL qualification, the Linux debug
suite and the Windows client suite pass. Refreshes the DEV session window.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
dingo
2026-10-21 18:08:59 -04:00
co-authored by Claude Opus 5.5
parent 3f82795c18
commit d2f603b582
39 changed files with 1106 additions and 103 deletions
+71 -7
View File
@@ -1,5 +1,6 @@
#include "cellular_scene.hpp"
#include "controls_flow.hpp"
#include "evo/biology/cellular_currents.hpp"
#include "evo/client/application.hpp"
#include "evo/client/auth.hpp"
#include "evo/client/launcher.hpp"
@@ -486,6 +487,12 @@ int main(int argc, char** argv) try {
std::uint64_t seen_deposit_tick{};
std::vector<LivePop> live_pops;
bool scene_active = false;
// Rules 12: the region's current field, regenerated when the perceived configuration
// changes, and when the latest perception arrived (to carry bubbles between views).
std::optional<evo::network::CellularCurrentsView> flow_config;
std::optional<evo::biology::CellularFlowField> flow_field;
std::uint64_t flow_view_tick = 0;
auto flow_view_at = std::chrono::steady_clock::now();
evo::client_app::PanelActions actions;
(*app)->set_overlay([&] {
evo::client_app::PanelView view;
@@ -741,6 +748,7 @@ int main(int argc, char** argv) try {
const double width = state.logical_width, height = state.logical_height;
// 2026-10-16 microscope view: in cellular play, patches and cells are a scene the
// panels draw as granules and living cells; elsewhere organisms stay rectangles.
scene.flows.clear();
scene.patches.clear();
scene.deposits.clear();
scene.pops.clear();
@@ -773,9 +781,65 @@ int main(int argc, char** argv) try {
p.seed = (static_cast<std::uint64_t>(patch.x_um) << 32U) ^ patch.y_um;
scene.patches.push_back(p);
}
// Rules 12 (v13): the current field from the perceived configuration, drawn
// as streaks across the visible area.
if (const auto* perception = cellular_remote->cellular_perception()) {
if (perception->currents != flow_config) {
flow_config = perception->currents;
flow_field.reset();
if (const auto& c = flow_config) {
auto made = evo::biology::CellularFlowField::generate(
{c->seed, c->width_um, c->height_um, c->pitch_um, c->min_count,
c->max_count, c->min_route_width_um, c->max_route_width_um,
c->min_speed_um_per_s, c->max_speed_um_per_s});
if (made)
flow_field = std::move(*made);
}
}
if (perception->tick != flow_view_tick) {
flow_view_tick = perception->tick;
flow_view_at = std::chrono::steady_clock::now();
}
const auto low = camera->screen_to_world({0, height});
const auto high = camera->screen_to_world({width, 0});
if (flow_field && low && high) {
const double span = std::max(high->x_mm - low->x_mm, 0.001);
const double step = std::max(0.4, span / 28);
for (double y = std::floor(low->y_mm / step) * step; y <= high->y_mm;
y += step)
for (double x = std::floor(low->x_mm / step) * step; x <= high->x_mm;
x += step) {
const auto flow =
flow_field->sample(static_cast<std::int64_t>(x * 1000),
static_cast<std::int64_t>(y * 1000));
const double vx = flow.x_q10 / 1024.0, vy = flow.y_q10 / 1024.0;
const double speed = std::hypot(vx, vy);
if (speed < 5)
continue;
const auto at = camera->world_to_screen({x, y});
const auto ahead = camera->world_to_screen(
{x + vx / speed * 0.001, y + vy / speed * 0.001});
if (!at || !ahead)
continue;
const double sx = ahead->x - at->x, sy = ahead->y - at->y;
const double norm = std::max(std::hypot(sx, sy), 1e-9);
const double length = 8 + std::min(speed, 300.0) / 300 * 16;
scene.flows.push_back(
{static_cast<float>(at->x), static_cast<float>(at->y),
static_cast<float>(sx / norm * length),
static_cast<float>(sy / norm * length),
static_cast<float>(std::min(speed, 300.0) / 300),
static_cast<std::uint32_t>(x * 7919 + y * 104729)});
}
}
}
// ADR-0136 (v11): pools and bubbles, centred; a vanished bubble pops.
if (const auto* perception = cellular_remote->cellular_perception()) {
const auto now_pop = std::chrono::steady_clock::now();
// Rules 12: carry each bubble along its perceived velocity since the view
// arrived (at most 300 ms), so moving food glides between perceptions.
const double carried = std::min(
std::chrono::duration<double>(now_pop - flow_view_at).count(), 0.3);
std::map<std::uint32_t, SeenDeposit> current;
for (const auto& d : perception->deposits) {
std::array<std::uint64_t, 5> stock{};
@@ -785,13 +849,13 @@ int main(int argc, char** argv) try {
for (std::size_t c = 1; c < stock.size(); ++c)
if (stock.at(c) > stock.at(static_cast<std::size_t>(channel)))
channel = static_cast<int>(c);
const SeenDeposit seen{static_cast<double>(d.x_um) / 1000,
static_cast<double>(d.y_um) / 1000,
d.radius_um,
channel,
d.drained,
d.shape ==
evo::network::CellularDepositShape::bubble};
const SeenDeposit seen{
(static_cast<double>(d.x_um) + d.velocity_x_um_s * carried) / 1000,
(static_cast<double>(d.y_um) + d.velocity_y_um_s * carried) / 1000,
d.radius_um,
channel,
d.drained,
d.shape == evo::network::CellularDepositShape::bubble};
current[d.id] = seen;
const auto centre = camera->world_to_screen({seen.x_mm, seen.y_mm});
const auto edge = camera->world_to_screen(
+14 -1
View File
@@ -89,7 +89,7 @@ std::string controls_hint(const client::Bindings& b) {
return "Click selects, wheel zooms. Move " + k(Action::move_up) + " " + k(Action::move_left) +
" " + k(Action::move_down) + " " + k(Action::move_right) + "; pan " + k(Action::pan_up) +
" " + k(Action::pan_left) + " " + k(Action::pan_down) + " " + k(Action::pan_right) +
"; UI capture " + k(Action::toggle_capture) + ".";
"; brake " + k(Action::brake) + "; UI capture " + k(Action::toggle_capture) + ".";
}
// Fixed wording only (never echoes paths or file bytes); wraps inside the launcher.
void error_text(client::LaunchError error) {
@@ -939,11 +939,24 @@ void inspect_cell(ImDrawList& list, const SceneCell& c) {
}
ImGui::EndTooltip();
}
// Rules 12: currents as faint drifting streaks under the food, so the flow is readable before
// a cell commits to it. Specks are thin lines, never discs, so they never read as food.
void draw_flows(ImDrawList& list, const std::vector<SceneFlow>& flows, float time) {
for (const auto& f : flows) {
const float phase = std::fmod(time * 0.5F + static_cast<float>(f.seed % 97U) / 97.0F, 1.0F);
const float fade = std::sin(phase * 3.14159265F);
const auto alpha = static_cast<unsigned>((24.0F + 80.0F * f.strength) * fade);
const ImVec2 from{f.x + f.dx * (phase - 0.5F), f.y + f.dy * (phase - 0.5F)};
const ImVec2 to{from.x + f.dx * 0.6F, from.y + f.dy * 0.6F};
list.AddLine(from, to, IM_COL32(140, 200, 235, alpha), 1.4F);
}
}
void draw_scene(const PanelView& v) {
if (!v.cellular_scene)
return;
auto& list = *ImGui::GetBackgroundDrawList();
const auto time = static_cast<float>(ImGui::GetTime());
draw_flows(list, v.cellular_scene->flows, time);
for (const auto& patch : v.cellular_scene->patches)
draw_patch(list, patch);
for (const auto& deposit : v.cellular_scene->deposits)
+6
View File
@@ -56,7 +56,13 @@ struct ScenePop {
float x{}, y{}, radius{}, age{}; // Age 0..1 over the pop's life.
int channel{};
};
// Rules 12: one streak of the local current; dx/dy in pixels, strength 0..1 by speed.
struct SceneFlow {
float x{}, y{}, dx{}, dy{}, strength{};
std::uint32_t seed{};
};
struct CellularScene {
std::vector<SceneFlow> flows;
std::vector<ScenePatch> patches;
std::vector<SceneDeposit> deposits;
std::vector<ScenePop> pops;
+5 -5
View File
@@ -501,8 +501,8 @@ class RemoteSession {
return false;
client::RegionSessionClientConfig config;
if (cellular_trial_)
// ADR-0176: v12 is v11 (deposits) plus captured light and visible producers.
config.protocol_version = network::session_protocol_v12;
// Rules 12: v13 is v12 (deposits, light, producers) plus liquid motion and brake.
config.protocol_version = network::session_protocol_v13;
const auto route = routes_.find(target_region_);
config.transport = route != routes_.end() ? route->second : transport_;
if (ticket_) { // A handoff: the ticket replaces a grant, once.
@@ -632,9 +632,9 @@ class RemoteSession {
organisms_.current(), cellular_feed_target_);
cellular_feed_target_ = steering.patch;
const auto id = cellular_play_.allocate_id();
if (id == 0 ||
!client_->send_cellular_action(id, tick, steering.intention.move_x,
steering.intention.move_y, cellular_feed_target_))
if (id == 0 || !client_->send_cellular_action(
id, tick, steering.intention.move_x, steering.intention.move_y,
cellular_feed_target_, false, false, steering.intention.brake))
return;
sent_tick_ = server_tick_;
cellular_sent_tick_ = tick;
+60 -5
View File
@@ -27,6 +27,9 @@
#include <vector>
namespace evo::server_app {
// Rules 12: moving bubbles listed per perception, nearest first (the tuning file's trial
// food.visible_moving_bubbles). Pools are always listed.
inline constexpr std::size_t cellular_visible_moving_bubbles = 256;
// Profile-4 network boundary. Biology and persistence remain owned by the cellular host;
// this bridge handles admission, v7-v9 action receipts, public cell replication and
// owner-filtered v8/v9 perception.
@@ -257,6 +260,25 @@ class CellularBridge {
diagnostics.bud = feedback->bud ? bud_outcome(*feedback->bud)
: network::CellularBudOutcome::not_requested;
}
// Rules 12 (v13): the authoritative motion state and the region's currents, from
// which the client regenerates the identical flow field.
const auto* field = state.flow_field();
if (field) {
diagnostics.velocity_x_q10 = life.motion.velocity_x_q10;
diagnostics.velocity_y_q10 = life.motion.velocity_y_q10;
diagnostics.heading = life.motion.heading;
const auto& c = state.liquid_rules().currents;
view.currents = network::CellularCurrentsView{c.seed,
c.width_um,
c.height_um,
c.pitch_um,
c.min_count,
c.max_count,
c.min_route_width_um,
c.max_route_width_um,
c.min_speed_um_per_s,
c.max_speed_um_per_s};
}
view.diagnostics = diagnostics;
view.patches.reserve(perceived->size());
// ADR-0136 (rules 8): pools and bubbles go out as v11 deposits, the nearest 512 to
@@ -284,16 +306,49 @@ class CellularBridge {
const auto before = deposit_stock_.find(patch.id);
deposit.drained = before != deposit_stock_.end() &&
(patch.available.energy.value < before->second.energy.value ||
std::ranges::any_of(std::array{0, 1, 2, 3}, [&](int c) {
const auto i = static_cast<std::size_t>(c);
return patch.available.matter.at(i).value <
before->second.matter.at(i).value;
}));
std::ranges::any_of(
std::array{0, 1, 2, 3},
[&](int c) {
const auto i = static_cast<std::size_t>(c);
return patch.available.matter.at(i).value <
before->second.matter.at(i).value;
}));
seen_stock_[patch.id] = patch.available;
// Rules 12 (v13): a bubble's world velocity, current plus induced drift, so the
// client can carry it between perceptions.
if (field && patch.kind == biology::CellularDepositKind::mote) {
const auto flow = field->sample(patch.address.x_um, patch.address.y_um);
std::int64_t drift_x{}, drift_y{};
if (const auto index = state.habitat().find(patch.address)) {
drift_x = state.habitat().patches()[*index].drift_x_q10;
drift_y = state.habitat().patches()[*index].drift_y_q10;
}
const auto um_s = [](std::int64_t q10) {
return static_cast<std::int16_t>(std::clamp<std::int64_t>(
q10 / biology::cellular_velocity_q10_per_um_s, -32'767, 32'767));
};
deposit.velocity_x_um_s = um_s(flow.x_q10 + drift_x);
deposit.velocity_y_um_s = um_s(flow.y_q10 + drift_y);
}
const auto dx = std::int64_t{patch.address.x_um} - centre_x;
const auto dy = std::int64_t{patch.address.y_um} - centre_y;
near.emplace_back(static_cast<std::uint64_t>(dx * dx + dy * dy), deposit);
}
// Rules 12: every pool, but only the nearest moving bubbles (the tuning file's
// trial 256); the client carries the rest with the current.
if (field) {
const auto bubbles = std::ranges::partition(near, [](const auto& entry) {
return entry.second.shape == network::CellularDepositShape::pool;
});
const auto keep = std::min<std::size_t>(cellular_visible_moving_bubbles,
static_cast<std::size_t>(bubbles.size()));
std::ranges::nth_element(
bubbles, bubbles.begin() + static_cast<std::ptrdiff_t>(keep),
[](const auto& a, const auto& b) {
return std::pair{a.first, a.second.id} < std::pair{b.first, b.second.id};
});
near.erase(bubbles.begin() + static_cast<std::ptrdiff_t>(keep), near.end());
}
if (near.size() > network::max_cellular_perceived_deposits) {
std::ranges::nth_element(
near,
+87 -22
View File
@@ -10,7 +10,7 @@
// evo-world-clone check-store --world W --region R --pg-* ... --objects DIR
// [--reserve-mib N]
// evo-world-clone provision --world W --region R --opening
// development-v1|primitive-v1|cellular-v1 to cellular-v8
// development-v1|primitive-v1|cellular-v1 to cellular-v9
// --pg-* ... --objects DIR --build HEX [--commit HEX32] [--retain-build]
// primitive-v1 also requires --frame N --source-id N, every --funding-*-* channel,
// and one or more ordered --site X,Y values.
@@ -25,6 +25,10 @@
// --patch: one or more --pool X,Y,RADIUS,SOURCE,ENERGY,C,N,P,O (centres, any micrometre)
// and/or --motes COUNT,SOURCE,ENERGY,C,N,P,O (bubbles per channel amount, scattered
// from the --commit bytes, so a genesis is reproducible).
// cellular-v8 (ADR-0176) also requires --light-pj N. cellular-v9 (rules 12, ADR-0177)
// is cellular-v8 followed by the liquid upgrade: it also requires --tuning FILE (the Git
// tuning file, whose region size must match --width-um/--height-um) and accepts
// --current-seed N (default: derived from the --commit bytes).
// primitive-v1 and cellular-v1/v2/v3 accept --life-allocator-start N
// (ADR-0123): the world's life-identity allocator is created once at the operator-audited
// start N; a later run leaves it untouched and refuses one that is below N.
@@ -84,6 +88,8 @@
#include <csignal>
#include <cstdio>
#include <filesystem>
#include <fstream>
#include <iterator>
#include <limits>
#include <optional>
#include <span>
@@ -118,13 +124,20 @@ struct Options {
std::vector<biology::CellularPatch> cellular_patches;
std::vector<biology::CellularPatch> cellular_pools; // cellular-v7
std::optional<biology::CellularMoteField> cellular_motes; // cellular-v7 and v8
std::optional<std::uint64_t> light_pj; // cellular-v8: pJ per square um per tick
std::optional<std::uint64_t> light_pj; // cellular-v8/v9: pJ per square um per tick
std::optional<std::string> tuning_path; // cellular-v9: the Git tuning file
std::optional<std::uint64_t> current_seed;
std::optional<biology::CellularTuning> tuning; // Parsed from tuning_path.
std::optional<std::uint64_t> life_allocator_start;
std::optional<persistence::Sha256Digest> build;
bool retain_build{};
bool crash{};
};
// The openings that declare light: cellular-v8, and cellular-v9 which adds the liquid upgrade.
bool lit_opening(std::string_view opening) {
return opening == "cellular-v8" || opening == "cellular-v9";
}
std::optional<std::uint64_t> number(std::string_view text) {
std::uint64_t value{};
const auto [end, error] = std::from_chars(text.data(), text.data() + text.size(), value);
@@ -336,10 +349,14 @@ std::optional<Options> parse(int argc, char** argv) {
(value == "development-v1" || value == "primitive-v1" || value == "cellular-v1" ||
value == "cellular-v2" || value == "cellular-v3" || value == "cellular-v4" ||
value == "cellular-v5" || value == "cellular-v6" || value == "cellular-v7" ||
value == "cellular-v8"))
value == "cellular-v8" || value == "cellular-v9"))
o.opening = value;
else if (o.command == "provision" && flag == "--light-pj" && n && *n > 0)
o.light_pj = n;
else if (o.command == "provision" && flag == "--tuning" && !value.empty())
o.tuning_path = std::string{value};
else if (o.command == "provision" && flag == "--current-seed" && n)
o.current_seed = n;
else if (o.command == "provision" && flag == "--frame" && n)
o.primitive_frame = n;
else if (o.command == "provision" && flag == "--source-id" && n)
@@ -423,11 +440,36 @@ std::optional<Options> parse(int argc, char** argv) {
return std::nullopt;
if (cellular_options)
return std::nullopt;
} else if (o.opening == "cellular-v7" || o.opening == "cellular-v8") {
} else if (o.opening == "cellular-v7" || lit_opening(o.opening)) {
// Pools and bubbles only: square patches belong to the earlier openings. Only
// cellular-v8 (ADR-0176) declares light.
if ((o.opening == "cellular-v8") != o.light_pj.has_value())
// cellular-v8 and v9 (ADR-0176) declare light; only v9 takes a tuning file.
if (lit_opening(o.opening) != o.light_pj.has_value() ||
(o.opening == "cellular-v9") != o.tuning_path.has_value() ||
(o.current_seed && o.opening != "cellular-v9"))
return std::nullopt;
if (o.tuning_path) {
std::ifstream file(*o.tuning_path, std::ios::binary);
const std::string text{std::istreambuf_iterator<char>(file),
std::istreambuf_iterator<char>()};
auto parsed = biology::parse_cellular_tuning(text);
if (!file.good() && !file.eof()) {
std::printf("tuning file unreadable: %s\n", o.tuning_path->c_str());
return std::nullopt;
}
if (!parsed) {
std::printf("tuning file refused at line %zu (%s): %s\n", parsed.error().line,
parsed.error().key.c_str(),
std::string{biology::describe(parsed.error().kind)}.c_str());
return std::nullopt;
}
if (!o.cellular_width_um || !o.cellular_height_um ||
parsed->region_width_um != *o.cellular_width_um ||
parsed->region_height_um != *o.cellular_height_um) {
std::puts("tuning region size differs from --width-um/--height-um");
return std::nullopt;
}
o.tuning = *parsed;
}
if (!o.primitive_frame || *o.primitive_frame == 0 || !o.primitive_source ||
*o.primitive_source == 0 || o.primitive_sites.empty() ||
!std::ranges::all_of(o.primitive_funding,
@@ -548,21 +590,39 @@ std::vector<std::uint8_t> probe_bytes() {
return out;
}
// cellular-v9 (rules 12): the liquid rules from the tuning file, for the opening's area and
// a current seed (given, or derived from the genesis commit's bytes 8-15).
std::optional<server::CellularLiquidRules> liquid_rules(const Options& o) {
if (o.opening != "cellular-v9" || !o.tuning || !o.cellular_width_um || !o.cellular_height_um)
return std::nullopt;
std::uint64_t seed = o.current_seed.value_or(0);
if (!o.current_seed) {
const auto commit = o.commit.value_or(persistence::Uuid{});
for (std::size_t i = 8; i < 16; ++i)
seed = (seed << 8U) | commit.at(i);
}
return server::cellular_liquid_rules(*o.tuning, {*o.cellular_width_um, *o.cellular_height_um},
seed);
}
// ADR-0176 cellular-v8: a cellular-v7 genesis taken through one empty tick and the durable
// bundle 9 -> 10 -> 11 -> 12 -> 13 upgrades, declaring the region's light. Resumable: it
// continues from whichever bundle the head has reached, and does nothing at bundle 13.
// bundle 9 -> 10 -> 11 -> 12 -> 13 upgrades, declaring the region's light. cellular-v9 adds the
// 13 -> 14 liquid upgrade. Resumable: it continues from whichever bundle the head has reached,
// and does nothing at its target bundle.
int finish_photosynthesis_opening(const Options& o, persistence::Postgres& db,
const persistence::FilesystemObjectStore& store,
std::uint64_t frame, const persistence::Sha256Digest& build,
std::uint64_t light_pj) {
std::uint64_t light_pj,
const std::optional<server::CellularLiquidRules>& liquid) {
const auto& key = o.source.key;
const auto target =
liquid ? persistence::cellular_v14_versions : persistence::cellular_v13_versions;
// A finished opening needs no lease: a rerun (every Argo sync's provision hook) runs
// while the region server holds it, and must report the region rather than fail.
if (const auto current = persistence::load_region_checkpoint(db, key, timeout); current) {
const auto manifest = persistence::decode_manifest(current->manifest);
if (manifest && manifest->profile == persistence::CheckpointProfile::cellular_lives_v1 &&
manifest->frame == frame &&
manifest->cellular_versions == persistence::cellular_v13_versions)
manifest->frame == frame && manifest->cellular_versions == target)
return 0;
}
auto lease =
@@ -580,13 +640,13 @@ int finish_photosynthesis_opening(const Options& o, persistence::Postgres& db,
auto head = persistence::load_region_checkpoint(db, key, timeout);
if (!head)
return finish(3);
for (unsigned step = 0; step < 6; ++step) {
for (unsigned step = 0; step < 7; ++step) {
const auto manifest = persistence::decode_manifest(head->manifest);
if (!manifest || manifest->profile != persistence::CheckpointProfile::cellular_lives_v1 ||
manifest->frame != frame)
return finish(4);
const auto& versions = manifest->cellular_versions;
if (versions == persistence::cellular_v13_versions)
if (versions == target)
return finish(0);
const auto id = [&] {
persistence::Uuid made{};
@@ -637,6 +697,9 @@ int finish_photosynthesis_opening(const Options& o, persistence::Postgres& db,
upgraded = persistence::migrate_cellular_photosynthesis_profile(
db, store, *lease, *head, id, build,
{light_pj, 1, {std::numeric_limits<std::uint64_t>::max() / 2}}, timeout);
else if (versions == persistence::cellular_v13_versions && liquid)
upgraded = persistence::migrate_cellular_liquid_profile(db, store, *lease, *head, id,
build, *liquid, timeout);
else
return finish(4);
if (!upgraded) {
@@ -654,7 +717,7 @@ int provision(const Options& o) {
const bool cellular = o.opening == "cellular-v1" || o.opening == "cellular-v2" ||
o.opening == "cellular-v3" || o.opening == "cellular-v4" ||
o.opening == "cellular-v5" || o.opening == "cellular-v6" ||
o.opening == "cellular-v7" || o.opening == "cellular-v8";
o.opening == "cellular-v7" || lit_opening(o.opening);
const auto primitive_frame = o.primitive_frame.value_or(0);
if ((primitive || cellular) && primitive_frame == 0)
return 2;
@@ -749,7 +812,7 @@ int provision(const Options& o) {
habitat_config.width_um = cellular_width_um;
habitat_config.height_um = cellular_height_um;
habitat_config.patches = o.cellular_patches;
if (o.opening == "cellular-v7" || o.opening == "cellular-v8") {
if (o.opening == "cellular-v7" || lit_opening(o.opening)) {
// ADR-0136 step A: pools and bubbles scattered from the genesis commit's bytes.
auto field = o.cellular_motes.value_or(biology::CellularMoteField{0, 1, {}, 0});
const auto commit = o.commit.value_or(persistence::Uuid{});
@@ -771,7 +834,7 @@ int provision(const Options& o) {
auto opening = server::CellularLives::create(
*primitive_opening, std::move(*habitat),
{{cellular_width_um, cellular_height_um}, 0, cellular_temperature_mk},
o.opening == "cellular-v7" || o.opening == "cellular-v8"
o.opening == "cellular-v7" || lit_opening(o.opening)
? server::CellularLivesProfile::foraging
: o.opening == "cellular-v6" ? server::CellularLivesProfile::reproduction
: o.opening == "cellular-v5" ? server::CellularLivesProfile::balance
@@ -815,7 +878,7 @@ int provision(const Options& o) {
std::puts("provision refused existing profile/frame mismatch");
return 4;
}
if (o.opening == "cellular-v8") {
if (lit_opening(o.opening)) {
if (manifest->sequence == 0 &&
!persistence::provision_cellular_region(*db, *store, o.source.key,
primitive_frame, *cellular_opening,
@@ -824,8 +887,9 @@ int provision(const Options& o) {
"--commit to resolve genesis");
return 4;
}
if (const auto finished = finish_photosynthesis_opening(
o, *db, *store, primitive_frame, build, o.light_pj.value_or(0));
if (const auto finished =
finish_photosynthesis_opening(o, *db, *store, primitive_frame, build,
o.light_pj.value_or(0), liquid_rules(o));
finished != 0)
return finished;
auto head = persistence::load_region_checkpoint(*db, o.source.key, timeout);
@@ -877,9 +941,10 @@ int provision(const Options& o) {
static_cast<unsigned>(made.error().kind));
return 4;
}
if (o.opening == "cellular-v8") {
if (const auto finished = finish_photosynthesis_opening(o, *db, *store, primitive_frame,
build, o.light_pj.value_or(0));
if (lit_opening(o.opening)) {
if (const auto finished =
finish_photosynthesis_opening(o, *db, *store, primitive_frame, build,
o.light_pj.value_or(0), liquid_rules(o));
finished != 0)
return finished;
auto head = persistence::load_region_checkpoint(*db, o.source.key, timeout);
@@ -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-20261021T212858-ccf85ec3:1792632538"}
- {name: REGION_SESSION_WINDOW, value: "dev-20261021T220859-3894c212:1792634939"}
- {name: REGION_M10_MAX_GRANT_LIFETIME, value: "14400"}
ports:
# QUIC (ADR-0090): UDP only; nothing listens on TCP 7400.
+48
View File
@@ -0,0 +1,48 @@
# ADR-0178: Durable liquid regions and session v13
## Status and scope
Accepted 2026-10-21. Implements phases 1-2 of the
[region and movement plan](../../Cellular_Region_Movement_Plan.md) under
[ADR-0177](0177-cellular-regions-world-linkage.md): rules 12 on the raw profile-4 path,
schema 58, the `cellular-v9` opening and session protocol v13. Trial numbers come from the
Git tuning file. DEV-only; no World0 operation.
## Decision
**Biology.** Genome schema 6 carries the movement arrangement (001-010, 100 = founder);
development 6 and founder 5 use it. A shared integer motion step (velocity relative to the
liquid, heading, funded thrust and braking, drag to exactly zero, sub-micrometre carry)
runs identically on server and client. Seeded looping currents are a condition, not stock.
Habitat format 3 moves bubbles with the current and the drift moving cells induce, merges
touching bubbles up to a cap, keeps pools fixed and addresses unique.
**Owner format 10, rules 12.** An explicit no-tick format-9/rules-11 upgrade declares the
liquid rules (current configuration, founder handling, deposit motion) taken from the
tuning file and a seed when the region opens; the server never reads the file. See
[schemas/cellular-lives-v10.md](../../schemas/cellular-lives-v10.md). Brake is a step
intent valid only under rules 12, carried in raw trace 4 as flag bit 1.
**Bundle 14, schema 58.** Bundle 14 `(12, 10, 2, 1, 1, 6, 5, 2, 1)` is admitted by
parser-local normalization to bundle 13, with bundle 12/13's births and mutation results,
and an exact fenced 13 -> 14 upgrade whose only input, the liquid rules, recovery reads
from the target. Schema 58 also widens the canonical action input: byte 13 bit 0 is brake.
Population, census and migration profiles do not admit bundle 14 (raw path only, per the
maintainer).
**Opening `cellular-v9`.** `cellular-v8` followed by the 13 -> 14 upgrade, with
`--tuning FILE` (region size must match) and an optional `--current-seed`; resumable and
idempotent at bundle 14. DEV mounts the tuning file into the provision Job as a generated
ConfigMap.
**Session v13.** v12 plus liquid motion in the owner's perception (velocity, heading and
the current configuration), deposit world velocities and a brake on cellular actions. See
[schemas/network/session-v13-cellular-liquid.md](../../schemas/network/session-v13-cellular-liquid.md).
## Consequences
DEV region 10 (60 x 60 mm) replaces region 9 as the served region; regions 1-9 stay stored.
The v13 client draws currents and carries bubbles between perceptions. Remaining from the
plan: client-side prediction of the owner's motion with the shared step, the thermal map
(phase 3), movement mutations (phase 4), wildlife that plans with inertia (phase 5), logout
and region capacity (phase 6), and live retuning without reopening a region.
+2
View File
@@ -1,5 +1,7 @@
# Architecture decision records
- [ADR-0178: Durable liquid regions and session v13](0178-durable-liquid-region.md) - rules 12 on owner format 10 (currents, moving food, liquid motion), raw bundle 14 and schema 58 with a 13 -> 14 upgrade from the Git tuning file, the `cellular-v9` opening and session v13 (motion, currents, brake).
- [ADR-0177: Cellular regions, world linkage and emergence](0177-cellular-regions-world-linkage.md) - maintainer-accepted direction: regions map to a world area rather than a voxel, currents and the thermal map are conditions not stock, capped regions refuse births, scaled emergence export, protected anchored logout; implementation pending.
- [ADR-0176: Durable photosynthesis regions and session v12](0176-durable-photosynthesis-region.md) - schema 57 raw bundle 13 (rules 11, owner format 9) with a light-declaring 12 -> 13 upgrade, the resumable `cellular-v8` opening and session v12 (captured light, visible producers, photosynthesis offers).
+3 -2
View File
@@ -22,9 +22,10 @@ enum class Action : std::uint8_t {
pan_right,
pan_up,
pan_down,
toggle_capture
toggle_capture,
brake // Rules 12: appended so earlier controls files keep their meaning.
};
inline constexpr std::size_t action_count = 9;
inline constexpr std::size_t action_count = 10;
using KeyCode = std::uint16_t; // HID usage; 0 means unbound.
inline constexpr KeyCode no_key = 0;
inline constexpr KeyCode escape_key = 41; // Reserved: cancels binding capture.
+14 -2
View File
@@ -6,7 +6,18 @@
#include <optional>
namespace evo::client {
enum class Key : std::uint8_t { left, right, up, down, pan_left, pan_right, pan_up, pan_down };
// `brake` (rules 12) opposes the cell's velocity relative to the liquid while held.
enum class Key : std::uint8_t {
left,
right,
up,
down,
pan_left,
pan_right,
pan_up,
pan_down,
brake
};
enum class InputError : std::uint8_t {
invalid_key,
invalid_pointer,
@@ -17,6 +28,7 @@ enum class InputError : std::uint8_t {
struct Intention {
std::uint64_t sequence{}, tick{};
std::int16_t move_x{}, move_y{}; // Signed unit vector *1000, local XY (+Y up).
bool brake{}; // Rules 12: held brake.
};
struct Navigation {
int x{}, y{};
@@ -49,7 +61,7 @@ class InputState {
private:
void clear() noexcept;
std::array<bool, 8> keys_{};
std::array<bool, 9> keys_{};
bool admitted_{false}, captured_{false};
ScreenPoint pointer_{};
double wheel_{};
+1 -1
View File
@@ -65,7 +65,7 @@ class RegionSessionClient {
send_cellular_action(std::uint64_t action_id, std::uint64_t tick, std::int16_t move_x,
std::int16_t move_y,
std::optional<std::pair<std::uint32_t, std::uint32_t>> intake_target = {},
bool engulf = false, bool bud = false);
bool engulf = false, bool bud = false, bool brake = false);
// Protocol v10 (ADR-0121): choose one candidate of the life's outstanding offer. The
// receipt names the tick it publishes with; the outcome follows that commit. `tick` is
// the client's latest simulated tick (after the offer); the server schedules the next.
+35 -5
View File
@@ -41,19 +41,28 @@ inline constexpr std::uint16_t session_protocol_v11 = 11;
// v12 (ADR-0176) is v11 plus the owner's captured light and visible producers in its
// perception, and the photosynthesis capability (7) in mutation offers.
inline constexpr std::uint16_t session_protocol_v12 = 12;
// v10, v11 and v12 share every cellular message but the perception's contents.
// v13 (rules 12, ADR-0177) is v12 plus liquid motion: the owner's velocity and heading and the
// region's current configuration in its perception, each deposit's world velocity, and a brake
// flag on cellular actions.
inline constexpr std::uint16_t session_protocol_v13 = 13;
// v10 to v13 share every cellular message but the perception's contents and v13's brake.
[[nodiscard]] constexpr bool cellular_v10_family(std::uint16_t version) noexcept {
return version == session_protocol_v10 || version == session_protocol_v11 ||
version == session_protocol_v12;
version == session_protocol_v12 || version == session_protocol_v13;
}
// Versions whose perception lists pools and bubbles (ADR-0136) instead of square patches.
[[nodiscard]] constexpr bool cellular_deposit_version(std::uint16_t version) noexcept {
return version == session_protocol_v11 || version == session_protocol_v12;
return version == session_protocol_v11 || version == session_protocol_v12 ||
version == session_protocol_v13;
}
// Versions that carry captured light and producers (ADR-0176).
[[nodiscard]] constexpr bool cellular_light_version(std::uint16_t version) noexcept {
return version == session_protocol_v12 || version == session_protocol_v13;
}
// The highest capability a version's mutation offers may name.
[[nodiscard]] constexpr std::uint8_t
cellular_offer_capability_limit(std::uint16_t version) noexcept {
return version == session_protocol_v12 ? 7 : 6;
return cellular_light_version(version) ? 7 : 6;
}
inline constexpr std::size_t max_cellular_perceived_patches = 256;
inline constexpr std::size_t max_cellular_perceived_deposits = 512;
@@ -197,7 +206,8 @@ struct CellularActionInput {
bool has_intake_target{};
std::uint32_t intake_x_um{}, intake_y_um{};
bool engulf{};
bool bud{}; // Kind 3 (ADR-0125): fund one wildlife bud, zero coordinates, v10 only.
bool bud{}; // Kind 3 (ADR-0125): fund one wildlife bud, zero coordinates, v10 only.
bool brake{}; // Byte 13 bit 0 (schema 58, rules 12): oppose relative velocity.
friend bool operator==(const CellularActionInput&, const CellularActionInput&) = default;
};
inline constexpr std::size_t cellular_action_input_bytes = 24;
@@ -212,6 +222,8 @@ struct CellularAction {
bool engulf{};
// v10 (ADR-0125): fund one wildlife bud; exclusive with intake and engulfment.
bool bud{};
// v13 (rules 12): brake against relative velocity instead of following the movement.
bool brake{};
friend bool operator==(const CellularAction&, const CellularAction&) = default;
};
// v10 reliable choice. The server binds these values to the authenticated account and
@@ -270,6 +282,8 @@ struct CellularPerceivedDeposit {
CellularDepositShape shape{CellularDepositShape::bubble};
bool drained{};
std::array<std::uint16_t, 5> amount_codes{}; // Energy, then C, N, P, other.
// v13 only: world velocity in um/s (current plus induced drift); zero for pools.
std::int16_t velocity_x_um_s{}, velocity_y_um_s{};
friend bool operator==(const CellularPerceivedDeposit&,
const CellularPerceivedDeposit&) = default;
};
@@ -339,6 +353,10 @@ struct CellularLifeDiagnostics {
std::uint64_t bud_cost_energy_pj{};
std::array<std::uint64_t, 4> bud_cost_matter_fg{};
std::uint64_t light_pj{}; // v12 only (ADR-0176): light this cell captured last tick.
// v13 only (rules 12): velocity relative to the liquid (Q10 um/s) and heading (65,536 per
// turn), the authoritative motion state the client predictor reconciles against.
std::int32_t velocity_x_q10{}, velocity_y_q10{};
std::uint16_t heading{};
friend bool operator==(const CellularLifeDiagnostics&,
const CellularLifeDiagnostics&) = default;
};
@@ -350,6 +368,16 @@ struct CellularPerceivedProducer {
friend bool operator==(const CellularPerceivedProducer&,
const CellularPerceivedProducer&) = default;
};
// v13 (rules 12): the region's current configuration; the client regenerates the identical
// flow field from it (biology::CellularFlowField).
struct CellularCurrentsView {
std::uint64_t seed{};
std::uint32_t width_um{}, height_um{}, pitch_um{};
std::uint32_t min_count{}, max_count{};
std::uint32_t min_route_width_um{}, max_route_width_um{};
std::uint32_t min_speed_um_per_s{}, max_speed_um_per_s{};
friend bool operator==(const CellularCurrentsView&, const CellularCurrentsView&) = default;
};
struct CellularPerception {
std::uint64_t tick{}, life_identity{}; // zero life plus no patches clears the view.
std::vector<CellularPerceivedPatch> patches; // strictly ordered by (x_um, y_um).
@@ -360,6 +388,8 @@ struct CellularPerception {
std::vector<CellularPerceivedDeposit> deposits{};
// v12 only: visible producers by ascending organism.
std::vector<CellularPerceivedProducer> producers{};
// v13 only, with an owner life in a liquid region.
std::optional<CellularCurrentsView> currents{};
friend bool operator==(const CellularPerception&, const CellularPerception&) = default;
};
struct IntentionReceipt {
@@ -286,6 +286,12 @@ migrate_cellular_photosynthesis_profile(Postgres&, const FilesystemObjectStore&,
const Sha256Digest& build, server::CellularLight light,
std::chrono::milliseconds timeout,
const PublishHooks& hooks = {});
// Rules 12: explicit raw-only bundle 13 -> 14, declaring the region's liquid rules.
[[nodiscard]] std::expected<CommittedCheckpoint, CellularProfileMigrationFailure>
migrate_cellular_liquid_profile(Postgres&, const FilesystemObjectStore&, const LeaseGrant&,
const CommittedCheckpoint&, Uuid commit, const Sha256Digest& build,
const server::CellularLiquidRules& rules,
std::chrono::milliseconds timeout, const PublishHooks& hooks = {});
// Verify the recorded no-tick operation under current authority, replaying its
// entire source/target payload. Version upgrades and profile transitions retain
// separate evidence; neither is inferred solely from the target tuple.
+14 -1
View File
@@ -87,9 +87,11 @@ inline constexpr CellularVersionBundle cellular_v11_versions{9, 7, 2, 1, 1, 4, 3
inline constexpr CellularVersionBundle cellular_v12_versions{10, 8, 2, 1, 1, 4, 3, 2, 1};
// ADR-0175/0176: rules 11 on owner format 9 (declared light), development 5, founder 4.
inline constexpr CellularVersionBundle cellular_v13_versions{11, 9, 2, 1, 1, 5, 4, 2, 1};
// Rules 12 on owner format 10 (liquid region), development 6, founder 5 (ADR-0177).
inline constexpr CellularVersionBundle cellular_v14_versions{12, 10, 2, 1, 1, 6, 5, 2, 1};
// Raw-only retained-plan bundles, which use trace 4 and their own SQL admission.
[[nodiscard]] constexpr bool cellular_plan_bundle(const CellularVersionBundle& b) noexcept {
return b == cellular_v12_versions || b == cellular_v13_versions;
return b == cellular_v12_versions || b == cellular_v13_versions || b == cellular_v14_versions;
}
// Zero means this bundle has no population representation.
[[nodiscard]] constexpr std::uint32_t
@@ -293,6 +295,17 @@ cellular_photosynthesis_upgrade_manifest(const CheckpointManifest& predecessor,
cellular_photosynthesis_upgrade_payload(std::span<const std::uint8_t> payload,
const CheckpointManifest& predecessor,
const server::CellularLight& light);
// Rules 12: explicit raw-only bundle 13 -> 14 upgrade declaring the region's liquid rules. As
// with light, the rules are the only input; recovery reads them from the target.
[[nodiscard]] std::expected<CheckpointManifest, CheckpointError>
cellular_liquid_upgrade_manifest(const CheckpointManifest& predecessor,
const Sha256Digest& predecessor_digest, Uuid commit,
const LeaseGrant& lease, const Sha256Digest& build,
std::uint64_t payload_bytes, const Sha256Digest& payload_sha256);
[[nodiscard]] std::expected<std::vector<std::uint8_t>, CheckpointError>
cellular_liquid_upgrade_payload(std::span<const std::uint8_t> payload,
const CheckpointManifest& predecessor,
const server::CellularLiquidRules& rules);
// ADR-0174: explicit one-way, no-tick profile 5 -> 6 transition. The payload wraps the
// identical population with its declared environment; bundle and policy are unchanged.
[[nodiscard]] std::expected<CheckpointManifest, CheckpointError>
+247
View File
@@ -0,0 +1,247 @@
-- Rules 12 (ADR-0177, Cellular_Region_Movement_Plan.md): raw-only bundle 14 (rules 12 on owner
-- format 10: liquid region with moving food) and exact bundle 13 -> 14 upgrades declaring the
-- region's liquid rules. Normalization is parser-local; stored evidence and retries retain real
-- bytes. Raw trace 4 is unchanged: its brake is a flag bit SQL never parses.
-- Byte 13 of the canonical cellular action input becomes a flags byte: bit 0 brake (rules
-- 12). Widening cannot invalidate an existing row; earlier inputs keep byte 13 zero.
CREATE OR REPLACE FUNCTION evolution.valid_cellular_action_input(p_input bytea, p_tick evolution.u64)
RETURNS boolean LANGUAGE plpgsql IMMUTABLE STRICT
SET search_path = pg_catalog, pg_temp AS $$
BEGIN
IF octet_length(p_input) <> 24 THEN
RETURN false;
END IF;
IF evolution.manifest_uint(p_input, 0, 8) = 0
OR evolution.manifest_uint(p_input, 0, 8) <> p_tick OR get_byte(p_input, 12) > 3
OR get_byte(p_input, 13) > 1 OR substring(p_input FROM 15 FOR 2) <> '\x0000' THEN
RETURN false;
END IF;
IF get_byte(p_input, 12) <> 1 AND substring(p_input FROM 17 FOR 8) <> '\x0000000000000000' THEN
RETURN false;
END IF;
RETURN true;
END $$;
ALTER FUNCTION evolution.parse_checkpoint_manifest(bytea) RENAME TO parse_checkpoint_manifest_v57;
REVOKE ALL ON FUNCTION evolution.parse_checkpoint_manifest_v57(bytea) FROM PUBLIC, :"runtime_role";
CREATE FUNCTION evolution.parse_checkpoint_manifest(m bytea)
RETURNS evolution.checkpoint_manifest LANGUAGE plpgsql IMMUTABLE
SET search_path=pg_catalog,pg_temp AS $$
DECLARE c evolution.checkpoint_manifest;
b13 constant bytea := '\x0b0000000900000002000000010000000100000005000000040000000200000001000000';
b14 constant bytea := '\x0c0000000a00000002000000010000000100000006000000050000000200000001000000';
BEGIN
IF m IS NOT NULL AND octet_length(m)=360 AND evolution.manifest_uint(m,12,4)=4
AND substring(m FROM 161 FOR 36)=b14 THEN
c := evolution.parse_checkpoint_manifest_v57(overlay(m PLACING b13 FROM 161 FOR 36));
c.versions := b14;
RETURN c;
END IF;
RETURN evolution.parse_checkpoint_manifest_v57(m);
END $$;
REVOKE ALL ON FUNCTION evolution.parse_checkpoint_manifest(bytea) FROM PUBLIC;
ALTER FUNCTION evolution.cellular_births(bytea,bytea) RENAME TO cellular_births_v57;
REVOKE ALL ON FUNCTION evolution.cellular_births_v57(bytea,bytea) FROM PUBLIC, :"runtime_role";
CREATE FUNCTION evolution.cellular_births(t bytea,m bytea)
RETURNS TABLE(account_id uuid,request_id evolution.u64,generation evolution.u64,identity evolution.u64,born evolution.u64)
LANGUAGE plpgsql IMMUTABLE SET search_path=pg_catalog,pg_temp AS $$
DECLARE c evolution.checkpoint_manifest := evolution.parse_checkpoint_manifest(m);
BEGIN
IF c.versions='\x0c0000000a00000002000000010000000100000006000000050000000200000001000000'::bytea THEN
m := overlay(m PLACING '\x0b0000000900000002000000010000000100000005000000040000000200000001000000'::bytea FROM 161 FOR 36);
END IF;
RETURN QUERY SELECT * FROM evolution.cellular_births_v57(t,m);
END $$;
REVOKE ALL ON FUNCTION evolution.cellular_births(bytea,bytea) FROM PUBLIC;
-- Results 1 life died, 3 declined, 4 offspring plan applied, for bundles 12, 13 and 14.
CREATE OR REPLACE FUNCTION evolution.check_cellular_mutation_block(p_manifest bytea, p_trace bytea,
p_mutations bytea, p_results bytea)
RETURNS integer LANGUAGE plpgsql STABLE SECURITY INVOKER
SET search_path = pg_catalog, pg_temp AS $$
DECLARE
c evolution.checkpoint_manifest := evolution.parse_checkpoint_manifest(p_manifest);
n integer;
account uuid;
account_bytes bytea;
action numeric;
tick numeric;
input bytea;
previous_tick numeric := -1;
previous_account bytea := ''::bytea;
previous_action numeric := -1;
r evolution.cellular_mutation_reservations%ROWTYPE;
BEGIN
IF p_mutations IS NULL OR p_results IS NULL OR octet_length(p_mutations) = 0
OR octet_length(p_mutations) % 64 <> 0 OR octet_length(p_mutations) / 64 > 1024
OR octet_length(p_results) <> octet_length(p_mutations) / 64 THEN
RAISE EXCEPTION 'invalid cellular mutation block' USING ERRCODE = '22023';
END IF;
n := octet_length(p_mutations) / 64;
IF (SELECT count(*) FROM evolution.cellular_mutation_selections(p_trace, p_manifest)) <> n THEN
RAISE EXCEPTION 'cellular mutation block does not cover the trace' USING ERRCODE = '22023';
END IF;
FOR i IN 0 .. n - 1 LOOP
account_bytes := substring(p_mutations FROM 64 * i + 1 FOR 16);
account := encode(account_bytes, 'hex')::uuid;
action := evolution.manifest_uint(p_mutations, 64 * i + 16, 8);
input := substring(p_mutations FROM 64 * i + 25 FOR 34);
tick := evolution.manifest_uint(input, 0, 8);
IF account = '00000000-0000-0000-0000-000000000000' OR action = 0
OR NOT evolution.valid_cellular_mutation_input(input)
OR substring(p_mutations FROM 64 * i + 59 FOR 6) <> '\x000000000000'
OR (c.versions IN ('\x0a0000000800000002000000010000000100000004000000030000000200000001000000'::bytea,
'\x0b0000000900000002000000010000000100000005000000040000000200000001000000'::bytea,
'\x0c0000000a00000002000000010000000100000006000000050000000200000001000000'::bytea)
AND (get_byte(p_results,i) NOT IN (1,3,4)
OR (evolution.manifest_uint(input,32,2)=0 AND get_byte(p_results,i) NOT IN (1,3))
OR (evolution.manifest_uint(input,32,2)<>0 AND get_byte(p_results,i) NOT IN (1,4))))
OR (c.versions NOT IN ('\x0a0000000800000002000000010000000100000004000000030000000200000001000000'::bytea,
'\x0b0000000900000002000000010000000100000005000000040000000200000001000000'::bytea,
'\x0c0000000a00000002000000010000000100000006000000050000000200000001000000'::bytea)
AND get_byte(p_results,i)>3)
OR tick <= c.begin_tick OR tick > c.end_tick
OR (tick, account_bytes, action) <= (previous_tick, previous_account, previous_action) THEN
RAISE EXCEPTION 'invalid cellular mutation record' USING ERRCODE = '22023';
END IF;
previous_tick := tick;
previous_account := account_bytes;
previous_action := action;
SELECT * INTO r FROM evolution.cellular_mutation_reservations x
WHERE x.world_id = c.world_id AND x.account_id = account AND x.action_id = action;
IF NOT FOUND OR r.region_id <> c.region_id OR r.input_bytes <> input
OR r.target_tick <> evolution.manifest_uint(input, 0, 8) THEN
RAISE EXCEPTION 'cellular mutation reservation conflicts' USING ERRCODE = 'EVL16';
END IF;
IF NOT EXISTS (SELECT 1 FROM evolution.cellular_mutation_selections(p_trace, p_manifest) s
WHERE s.tick = r.target_tick AND s.successor_identity = r.successor_identity
AND s.life_id = evolution.manifest_uint(input, 8, 8)
AND s.event_index = evolution.manifest_uint(input, 16, 8)
AND s.offer_tick = evolution.manifest_uint(input, 24, 8)
AND s.operator_id = evolution.manifest_uint(input, 32, 2)) THEN
RAISE EXCEPTION 'cellular mutation differs from its trace' USING ERRCODE = '22023';
END IF;
END LOOP;
RETURN n;
END $$;
ALTER FUNCTION evolution.publish_cellular_profile_migration(bytea) RENAME TO publish_cellular_profile_migration_v57;
REVOKE ALL ON FUNCTION evolution.publish_cellular_profile_migration_v57(bytea) FROM PUBLIC, :"runtime_role";
CREATE OR REPLACE FUNCTION evolution.publish_cellular_profile_migration(p_manifest bytea)
RETURNS TABLE(region_frame evolution.u64, head_sequence evolution.u64, head_commit uuid,
head_digest text, head_tick evolution.u64)
LANGUAGE plpgsql SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS $$
DECLARE
c evolution.checkpoint_manifest := evolution.parse_checkpoint_manifest(p_manifest);
s evolution.checkpoint_manifest;
h evolution.region_heads%ROWTYPE;
p evolution.region_commits%ROWTYPE;
old evolution.region_commits%ROWTYPE;
frame evolution.u64;
d bytea := sha256(p_manifest);
source_bundle constant bytea := '\x0b0000000900000002000000010000000100000005000000040000000200000001000000';
target_bundle constant bytea := '\x0c0000000a00000002000000010000000100000006000000050000000200000001000000';
zero32 constant bytea := decode(repeat('00', 32), 'hex');
BEGIN
IF c.versions <> target_bundle THEN
RETURN QUERY SELECT * FROM evolution.publish_cellular_profile_migration_v57(p_manifest);
RETURN;
END IF;
IF c.profile <> 4 OR c.commit_sequence = 0 OR c.begin_tick <> c.end_tick
OR c.end_tick = 0 OR c.versions <> target_bundle
OR evolution.manifest_uint(p_manifest, 228, 4) <> 0
OR evolution.manifest_uint(p_manifest, 232, 4) <> (CASE c.profile WHEN 4 THEN 4 ELSE 5 END)
OR evolution.manifest_uint(p_manifest, 236, 4) <> 1
OR c.trace_bytes <> 0 OR c.trace_sha256 <> zero32
OR c.decision_count <> 0 OR c.decisions_sha256 <> zero32 THEN
RAISE EXCEPTION 'invalid liquid profile migration' USING ERRCODE = '22023';
END IF;
PERFORM evolution.check_region_lease(c.world_id, c.region_id, c.holder, c.epoch);
SELECT * INTO old FROM evolution.region_commits r WHERE r.commit_id = c.commit_id;
IF FOUND THEN
IF old.manifest <> p_manifest THEN
RAISE EXCEPTION 'cellular profile migration identity reused' USING ERRCODE = 'EVL07';
END IF;
SELECT * INTO p FROM evolution.region_commits r
WHERE r.world_id = old.world_id AND r.region_id = old.region_id
AND r.commit_sequence = old.commit_sequence - 1;
IF NOT FOUND OR NOT EXISTS (
SELECT 1 FROM evolution.cellular_profile_migrations m
WHERE m.target_commit = c.commit_id AND m.world_id = c.world_id
AND m.region_id = c.region_id AND m.source_sequence = p.commit_sequence
AND m.source_commit = p.commit_id AND m.source_manifest_sha256 = p.commit_digest
AND m.source_payload_sha256 = p.payload_sha256 AND m.source_versions = p.versions
AND m.target_sequence = old.commit_sequence AND m.target_manifest_sha256 = d
AND m.target_payload_sha256 = old.payload_sha256 AND m.target_versions = old.versions
AND m.source_commit = c.predecessor_commit
AND m.source_manifest_sha256 = c.predecessor_digest) THEN
RAISE EXCEPTION 'cellular profile migration identity reused' USING ERRCODE = 'EVL07';
END IF;
SELECT l.frame_id INTO frame FROM evolution.region_leases l
WHERE l.world_id = c.world_id AND l.region_id = c.region_id;
RETURN QUERY SELECT frame, old.commit_sequence, old.commit_id,
encode(old.commit_digest, 'hex'), old.end_tick;
RETURN;
END IF;
IF EXISTS (SELECT 1 FROM evolution.population_interval_pending x
WHERE x.world_id = c.world_id AND x.region_id = c.region_id) THEN
RAISE EXCEPTION 'liquid upgrade waits for interval' USING ERRCODE = 'EVL18';
END IF;
IF EXISTS (SELECT 1 FROM evolution.cellular_mutation_reservations x
WHERE x.world_id=c.world_id AND x.region_id=c.region_id AND NOT EXISTS
(SELECT 1 FROM evolution.cellular_mutation_action_publications a
WHERE a.world_id=x.world_id AND a.account_id=x.account_id AND a.action_id=x.action_id)) THEN
RAISE EXCEPTION 'liquid upgrade waits for mutation choice' USING ERRCODE='EVL18';
END IF;
SELECT * INTO h FROM evolution.region_heads r
WHERE r.world_id = c.world_id AND r.region_id = c.region_id FOR UPDATE;
IF NOT FOUND OR h.commit_sequence = 18446744073709551615
OR c.commit_sequence <> h.commit_sequence + 1 OR c.predecessor_commit <> h.commit_id
OR c.predecessor_digest <> h.digest OR c.begin_tick <> h.end_tick THEN
RAISE EXCEPTION 'region head moved' USING ERRCODE = 'EVL03';
END IF;
SELECT * INTO p FROM evolution.region_commits r
WHERE r.world_id = c.world_id AND r.region_id = c.region_id
AND r.commit_sequence = h.commit_sequence;
IF NOT FOUND THEN
RAISE EXCEPTION 'missing migration predecessor' USING ERRCODE = 'XX000';
END IF;
s := evolution.parse_checkpoint_manifest(p.manifest);
IF s.profile <> c.profile OR s.versions <> source_bundle OR p.versions <> source_bundle
OR c.frame_id <> s.frame_id OR c.tick_microseconds <> s.tick_microseconds
OR s.commit_id <> c.predecessor_commit OR s.end_tick <> c.end_tick
OR evolution.manifest_uint(p.manifest, 232, 4) <> (CASE c.profile WHEN 4 THEN 4 ELSE 5 END)
OR NOT EXISTS (SELECT 1 FROM evolution.retained_builds b
WHERE b.build_identity = c.build_identity) THEN
RAISE EXCEPTION 'unsupported liquid profile migration' USING ERRCODE = 'EVL06';
END IF;
SELECT l.frame_id INTO frame FROM evolution.region_leases l
WHERE l.world_id = c.world_id AND l.region_id = c.region_id;
IF c.frame_id <> frame THEN
RAISE EXCEPTION 'foreign frame' USING ERRCODE = '22023';
END IF;
INSERT INTO evolution.cellular_profile_migrations(target_commit, world_id, region_id,
source_sequence, source_commit, source_manifest_sha256, source_payload_sha256,
source_versions, target_sequence, target_manifest_sha256, target_payload_sha256,
target_versions)
VALUES (c.commit_id, c.world_id, c.region_id, p.commit_sequence, p.commit_id,
p.commit_digest, p.payload_sha256, p.versions, c.commit_sequence, d,
c.payload_sha256, c.versions);
INSERT INTO evolution.region_commits(world_id, region_id, commit_sequence, commit_id,
commit_digest, manifest, begin_tick, end_tick, published_epoch, tick_microseconds,
versions, build_identity, payload_bytes, payload_sha256)
VALUES (c.world_id, c.region_id, c.commit_sequence, c.commit_id, d, p_manifest,
c.begin_tick, c.end_tick, c.epoch, c.tick_microseconds, c.versions,
c.build_identity, c.payload_bytes, c.payload_sha256);
UPDATE evolution.region_heads r
SET commit_sequence = c.commit_sequence, commit_id = c.commit_id, digest = d,
end_tick = c.end_tick, published_epoch = c.epoch
WHERE r.world_id = c.world_id AND r.region_id = c.region_id;
RETURN QUERY SELECT frame, c.commit_sequence, c.commit_id, encode(d, 'hex'), c.end_tick;
END $$;
REVOKE ALL ON FUNCTION evolution.publish_cellular_profile_migration(bytea) FROM PUBLIC;
GRANT EXECUTE ON FUNCTION evolution.publish_cellular_profile_migration(bytea) TO :"runtime_role";
INSERT INTO evolution.schema_migrations(version,sha256) VALUES(58,:'migration_sha_58');
+12 -3
View File
@@ -133,6 +133,7 @@ SELECT EXISTS (SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname='evolution')
SELECT :'history_v54' || ',55:' || :'migration_sha_55' AS history_v55 \gset
SELECT :'history_v55' || ',56:' || :'migration_sha_56' AS history_v56 \gset
SELECT :'history_v56' || ',57:' || :'migration_sha_57' AS history_v57 \gset
SELECT :'history_v57' || ',58:' || :'migration_sha_58' AS history_v58 \gset
SELECT :'history' = :'history_v22' AS at_v22,
:'history' = :'history_v23' AS at_v23,
:'history' = :'history_v24' AS at_v24,
@@ -168,8 +169,10 @@ SELECT EXISTS (SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname='evolution')
:'history' = :'history_v54' AS at_v54,
:'history' = :'history_v55' AS at_v55,
:'history' = :'history_v56' AS at_v56,
:'history' = :'history_v57' AS at_v57 \gset
\if :at_v57
:'history' = :'history_v57' AS at_v57,
:'history' = :'history_v58' AS at_v58 \gset
\if :at_v58
\elif :at_v57
\elif :at_v56
\elif :at_v55
\elif :at_v54
@@ -577,7 +580,8 @@ SELECT coalesce(max(version), 0) = 24 AS at_v24,
coalesce(max(version), 0) = 54 AS at_v54,
coalesce(max(version), 0) = 55 AS at_v55,
coalesce(max(version), 0) = 56 AS at_v56,
coalesce(max(version), 0) = 57 AS at_v57
coalesce(max(version), 0) = 57 AS at_v57,
coalesce(max(version), 0) = 58 AS at_v58
FROM evolution.schema_migrations \gset
\if :at_v24
\ir 0025_cellular_v2_bundle.sql
@@ -803,6 +807,7 @@ SELECT coalesce(max(version), 0) = 24 AS at_v24,
\elif :at_v55
\elif :at_v56
\elif :at_v57
\elif :at_v58
\else
\echo 'Unknown or changed migration history after v43'
DO $$ BEGIN RAISE EXCEPTION 'unknown or changed migration history'; END $$;
@@ -863,6 +868,10 @@ SELECT coalesce(max(version), 0) = 56 AS needs_v57 FROM evolution.schema_migrati
\if :needs_v57
\ir 0057_photosynthesis_bundle.sql
\endif
SELECT coalesce(max(version), 0) = 57 AS needs_v58 FROM evolution.schema_migrations \gset
\if :needs_v58
\ir 0058_liquid_bundle.sql
\endif
-- Effective-privilege audit on every run, including no-ops (ADR-0060). Attributes
-- alone are insufficient: predefined roles such as pg_write_all_data, PUBLIC
-- grants or SET-able memberships would bypass the fenced functions. Checks the
+27
View File
@@ -0,0 +1,27 @@
# Cellular owner format 10: liquid region
Authority: [ADR-0178](../docs/adr/0178-durable-liquid-region.md). Format 10 is exactly
rules 12. It is [format 9](cellular-lives-v9.md) with magic `AEVCLV10`, an 88-byte liquid
block after the light block, 20 more bytes per life and a format-3 habitat; every other
record, length rule and validation is format 9's.
| Offset | Bytes | Field |
|---:|---:|---|
| 356 | 8 | Current seed |
| 364 | 4 each | Current width, height (the owner's area), grid pitch, minimum and maximum count, minimum and maximum route width (um), minimum and maximum speed (um/s) |
| 400 | 4 each | Founder handling per 50 ms tick: thrust (Q10 um/s), reverse thrust (Q10 um/s), forward drag (ppm), lateral drag (ppm), turn (heading units, at most 32,768) |
| 420 | 4 each | Deposit motion: drift radius (um), maximum drift (Q10 um/s), drift decay (ppm per tick), merged cap (at most 65,535), bubble radius (um) |
| 440 | 4 | Reserved zero |
| 444 | 8 each | Sorted spawn sites, then lives, corpses and the rest as in format 9 |
Each life record appends its motion state after the offspring genome: velocity relative to
the liquid x and y (signed Q10 um/s, within +/- 1 m/s), heading (u16, 65,536 per turn),
reserved u16 zero, and the sub-micrometre carry x and y (u32, below 1,024,000,000).
The habitat is format 3: format 2 deposits with induced drift, carry and a merged count
(see `evo/biology/cellular_habitat.hpp`). Restore regenerates the current field from the
block and refuses one that does not generate. Currents and the field are conditions, not
stock: closure is format 9's.
Format 10 arises only from the explicit no-tick format-9/rules-11 liquid upgrade, which
converts the habitat to format 3 (every deposit one merged bubble) and starts lives at rest.
@@ -0,0 +1,27 @@
# Session v13: liquid motion
Authority: [ADR-0178](../../docs/adr/0178-durable-liquid-region.md). v13 is
[v12](session-v12-cellular-producers.md) with liquid motion; every other message and rule is
v12's. Older versions keep their exact layouts.
**Perception.** The v12 prefix is followed by a 56-byte liquid block:
| Bytes | Field |
|---:|---|
| 4 | Owner velocity relative to the liquid, x (signed Q10 um/s) |
| 4 | Owner velocity, y |
| 2 | Owner heading (65,536 per turn) |
| 1 | Flags: bit 0 currents present; other bits zero |
| 1 | Reserved zero |
| 8 | Current seed |
| 4 each | Width, height, pitch, minimum and maximum count, minimum and maximum route width, minimum and maximum speed |
Without an owner life the flag and every field are zero. With the flag clear the current
fields are zero. A client regenerates the identical field from the configuration with
`biology::CellularFlowField`. Each deposit entry appends its world velocity (current plus
induced drift) as two signed 16-bit um/s values, zero for pools: 30 bytes per entry. A
rules-12 server lists every pool and only the nearest 256 moving bubbles.
**Cellular action.** Byte 37 (reserved through v12) is a flags byte: bit 0 brake. A brake
opposes the cell's velocity relative to the liquid instead of following the movement; the
canonical 24-byte action input stores it as byte 13 bit 0 (schema 58).
+15
View File
@@ -121,6 +121,7 @@ constexpr std::array<NamedAction, action_count> actions{{
{"pan_up", "Pan up"},
{"pan_down", "Pan down"},
{"toggle_capture", "Toggle UI capture"},
{"brake", "Brake"},
}};
constexpr KeySlots default_slots{{
{4, no_key}, // A
@@ -132,6 +133,7 @@ constexpr KeySlots default_slots{{
{82, no_key}, // Up
{81, no_key}, // Down
{43, no_key}, // Tab
{44, no_key}, // Space
}};
constexpr std::string_view header = "evo-controls";
@@ -327,6 +329,19 @@ std::expected<Bindings, BindingProblem> parse_bindings(std::string_view text) {
return std::unexpected(problem(BindingError::malformed, action));
slot = {*primary, *secondary};
}
// A file written before an action existed (brake, rules 12) takes that action's default
// key when no other action uses it; otherwise Bindings::make reports it as missing. The
// original version-1 actions stay required.
for (auto k = static_cast<std::size_t>(Action::brake); k < action_count; ++k) {
if (seen[k])
continue;
const auto key = default_slots[k].primary;
const bool taken = std::ranges::any_of(slots, [key](const KeySlot& other) {
return other.primary == key || other.secondary == key;
});
if (!taken)
slots[k] = {key, no_key};
}
if (!versioned)
return std::unexpected(problem(BindingError::malformed));
return Bindings::make(slots); // Missing actions have no primary.
+1 -1
View File
@@ -69,6 +69,6 @@ std::expected<Intention, InputError> InputState::sample(std::uint64_t tick) {
const int magnitude = x != 0 && y != 0 ? 707 : 1000;
tick_ = tick;
return Intention{++sequence_, tick, static_cast<std::int16_t>(x * magnitude),
static_cast<std::int16_t>(y * magnitude)};
static_cast<std::int16_t>(y * magnitude), keys_[8]};
}
} // namespace evo::client
+2
View File
@@ -19,6 +19,8 @@ bool runtime_owned = false; // Process main-thread-only contract; no hidden thre
std::optional<Key> held_key(Action action) noexcept {
if (action == Action::toggle_capture)
return std::nullopt;
if (action == Action::brake)
return Key::brake;
return static_cast<Key>(static_cast<std::uint8_t>(action));
}
static_assert(static_cast<int>(Action::pan_down) == static_cast<int>(Key::pan_down));
+8 -5
View File
@@ -308,17 +308,20 @@ bool RegionSessionClient::send_action(std::uint64_t action_id, network::ActionKi
bool RegionSessionClient::send_cellular_action(
std::uint64_t action_id, std::uint64_t tick, std::int16_t move_x, std::int16_t move_y,
std::optional<std::pair<std::uint32_t, std::uint32_t>> intake_target, bool engulf, bool bud) {
std::optional<std::pair<std::uint32_t, std::uint32_t>> intake_target, bool engulf, bool bud,
bool brake) {
auto& m = *impl_;
return (m.protocol_version == network::session_protocol_v7 ||
m.protocol_version == network::session_protocol_v8 ||
m.protocol_version == network::session_protocol_v9 ||
network::cellular_v10_family(m.protocol_version)) &&
m.state == RegionSessionState::established && m.welcome && action_id != 0 && tick != 0 &&
m.send(network::CellularAction{m.welcome->session, m.welcome->epoch, action_id, tick,
move_x, move_y, intake_target.has_value(),
intake_target ? intake_target->first : 0,
intake_target ? intake_target->second : 0, engulf, bud});
m.send(network::CellularAction{
m.welcome->session, m.welcome->epoch, action_id, tick, move_x, move_y,
intake_target.has_value(), intake_target ? intake_target->first : 0,
intake_target ? intake_target->second : 0, engulf, bud,
// A brake needs v13; older sessions never send one.
brake && m.protocol_version == network::session_protocol_v13});
}
bool RegionSessionClient::send_cellular_mutation(std::uint64_t action_id, std::uint64_t tick,
+2 -2
View File
@@ -240,7 +240,7 @@ ActionReceipt IntentAdmission::action(std::uint64_t session, const CellularActio
static_cast<std::uint16_t>(ActionKind::cellular), m.tick};
const auto bytes =
encode_cellular_action_input({m.tick, m.move_x, m.move_y, m.has_intake_target,
m.intake_x_um, m.intake_y_um, m.engulf, m.bud});
m.intake_x_um, m.intake_y_um, m.engulf, m.bud, m.brake});
auto* s = find(session);
if (!s)
return {m.action_id, AdmitStatus::unknown_session, facts.server_tick, m.tick};
@@ -282,7 +282,7 @@ std::optional<ActionReceipt> IntentAdmission::admit(std::uint64_t session, const
static_cast<std::uint16_t>(ActionKind::cellular), m.tick};
const auto bytes =
encode_cellular_action_input({m.tick, m.move_x, m.move_y, m.has_intake_target,
m.intake_x_um, m.intake_y_um, m.engulf, m.bud});
m.intake_x_um, m.intake_y_um, m.engulf, m.bud, m.brake});
auto* s = find(session);
if (!s)
return ActionReceipt{m.action_id, AdmitStatus::unknown_session, facts.server_tick, m.tick};
+104 -18
View File
@@ -32,9 +32,17 @@ constexpr std::size_t cellular_perception_v12_prefix_bytes =
cellular_perception_v10_prefix_bytes + 8 + 2 + 6;
// v12: organism, photosynthesis per thousand and 6 reserved bytes.
constexpr std::size_t cellular_perceived_producer_bytes = 8 + 2 + 6;
// v13 (rules 12) appends the owner's velocity (2 x i32) and heading (u16), a flags byte
// (bit 0: currents present), a reserved byte, and the current seed and nine u32 fields.
constexpr std::size_t cellular_liquid_block_bytes = 4 + 4 + 2 + 1 + 1 + 8 + (9 * 4);
constexpr std::size_t cellular_perception_v13_prefix_bytes =
cellular_perception_v12_prefix_bytes + cellular_liquid_block_bytes;
constexpr std::size_t cellular_perceived_patch_bytes = 8 + 8 + (4 * 8);
// v11: id, centre, radius, shape, drained flag and five 16-bit amount codes.
constexpr std::size_t cellular_perceived_deposit_bytes = 4 + 4 + 4 + 2 + 1 + 1 + (5 * 2);
// v13: the same plus world velocity as two 16-bit um/s values.
constexpr std::size_t cellular_perceived_liquid_deposit_bytes =
cellular_perceived_deposit_bytes + 4;
constexpr std::size_t intention_receipt_bytes = 8 + 1 + 8;
constexpr std::size_t simulated_bytes = std::size_t{3} * 8;
constexpr std::size_t action_bytes = (std::size_t{3} * 8) + 2 + 8;
@@ -227,8 +235,20 @@ std::vector<std::uint8_t> encode_session(const SessionMessage& message, std::uin
!cellular_v10_family(version) && std::holds_alternative<CellularPerception>(message))
return {};
if (const auto* perception = std::get_if<CellularPerception>(&message)) {
// v12 alone carries captured light and producers (ADR-0176).
const bool producers = version == session_protocol_v12;
// v12 and v13 carry captured light and producers (ADR-0176); v13 alone carries
// liquid motion.
const bool producers = cellular_light_version(version);
const bool liquid = version == session_protocol_v13;
if (!liquid && (perception->currents ||
(perception->diagnostics && (perception->diagnostics->velocity_x_q10 ||
perception->diagnostics->velocity_y_q10 ||
perception->diagnostics->heading)) ||
std::ranges::any_of(perception->deposits, [](const auto& d) {
return d.velocity_x_um_s != 0 || d.velocity_y_um_s != 0;
})))
return {};
if (perception->currents && !perception->life_identity)
return {};
if ((!producers && (!perception->producers.empty() ||
(perception->diagnostics && perception->diagnostics->light_pj))) ||
perception->producers.size() > max_cellular_perceived_producers ||
@@ -337,7 +357,8 @@ std::vector<std::uint8_t> encode_session(const SessionMessage& message, std::uin
put(out, static_cast<std::uint16_t>(m.move_x), 2);
put(out, static_cast<std::uint16_t>(m.move_y), 2);
out.push_back(m.has_intake_target ? 1 : m.engulf ? 2 : m.bud ? 3 : 0); // Target kind.
put(out, 0, 3);
out.push_back(m.brake ? 1 : 0); // v13 flags: bit 0 brake.
put(out, 0, 2);
put(out, m.intake_x_um, 4);
put(out, m.intake_y_um, 4);
return out;
@@ -386,12 +407,15 @@ std::vector<std::uint8_t> encode_session(const SessionMessage& message, std::uin
std::vector<std::uint8_t> operator()(const CellularPerception& m) const {
auto out =
header(SessionMessageType::cellular_perception,
(version == session_protocol_v12 ? cellular_perception_v12_prefix_bytes
: cellular_v10_family(version) ? cellular_perception_v10_prefix_bytes
: version == session_protocol_v9 ? cellular_perception_v9_prefix_bytes
: cellular_perception_prefix_bytes) +
(version == session_protocol_v13 ? cellular_perception_v13_prefix_bytes
: version == session_protocol_v12 ? cellular_perception_v12_prefix_bytes
: cellular_v10_family(version) ? cellular_perception_v10_prefix_bytes
: version == session_protocol_v9 ? cellular_perception_v9_prefix_bytes
: cellular_perception_prefix_bytes) +
m.patches.size() * cellular_perceived_patch_bytes +
m.deposits.size() * cellular_perceived_deposit_bytes +
m.deposits.size() * (version == session_protocol_v13
? cellular_perceived_liquid_deposit_bytes
: cellular_perceived_deposit_bytes) +
m.producers.size() * cellular_perceived_producer_bytes,
version);
put(out, m.tick, 8);
@@ -417,11 +441,25 @@ std::vector<std::uint8_t> encode_session(const SessionMessage& message, std::uin
for (const auto value :
d ? d->bud_cost_matter_fg : std::array<std::uint64_t, 4>{})
put(out, value, 8);
if (version == session_protocol_v12) {
if (cellular_light_version(version)) {
put(out, d ? d->light_pj : 0, 8);
put(out, m.producers.size(), 2);
put(out, 0, 6);
}
if (version == session_protocol_v13) {
put(out, static_cast<std::uint32_t>(d ? d->velocity_x_q10 : 0), 4);
put(out, static_cast<std::uint32_t>(d ? d->velocity_y_q10 : 0), 4);
put(out, d ? d->heading : 0, 2);
out.push_back(m.currents ? 1 : 0);
out.push_back(0);
const auto c = m.currents.value_or(CellularCurrentsView{});
put(out, c.seed, 8);
for (const auto value :
{c.width_um, c.height_um, c.pitch_um, c.min_count, c.max_count,
c.min_route_width_um, c.max_route_width_um, c.min_speed_um_per_s,
c.max_speed_um_per_s})
put(out, value, 4);
}
} else {
put(out, 0, 5);
}
@@ -442,6 +480,10 @@ std::vector<std::uint8_t> encode_session(const SessionMessage& message, std::uin
out.push_back(deposit.drained ? 1 : 0);
for (const auto code : deposit.amount_codes)
put(out, code, 2);
if (version == session_protocol_v13) {
put(out, static_cast<std::uint16_t>(deposit.velocity_x_um_s), 2);
put(out, static_cast<std::uint16_t>(deposit.velocity_y_um_s), 2);
}
}
for (const auto& producer : m.producers) {
put(out, producer.organism, 8);
@@ -679,12 +721,14 @@ std::expected<SessionMessage, SessionCodecError> decode_session(std::span<const
m.move_x = static_cast<std::int16_t>(static_cast<std::uint16_t>(get(payload, 32, 2)));
m.move_y = static_cast<std::int16_t>(static_cast<std::uint16_t>(get(payload, 34, 2)));
// Target kind: 0 none, 1 patch intake, 2 engulf and 3 bud (v10 only, ADR-0124/0125).
if (payload[36] > (cellular_v10_family(wire_version) ? 3 : 1) || payload[37] != 0 ||
payload[38] != 0 || payload[39] != 0)
if (payload[36] > (cellular_v10_family(wire_version) ? 3 : 1) ||
payload[37] > (wire_version == session_protocol_v13 ? 1 : 0) || payload[38] != 0 ||
payload[39] != 0)
return std::unexpected(SessionCodecError::invalid_value);
m.has_intake_target = payload[36] == 1;
m.engulf = payload[36] == 2;
m.bud = payload[36] == 3;
m.brake = payload[37] == 1;
m.intake_x_um = static_cast<std::uint32_t>(get(payload, 40, 4));
m.intake_y_um = static_cast<std::uint32_t>(get(payload, 44, 4));
if (!m.session || !m.epoch || !m.action_id || !m.tick ||
@@ -778,16 +822,19 @@ std::expected<SessionMessage, SessionCodecError> decode_session(std::span<const
const bool without_bud_cost = wire_version == session_protocol_v10 &&
payload.size() == cellular_perception_v9_prefix_bytes +
count * cellular_perceived_patch_bytes;
const bool lit = wire_version == session_protocol_v12;
const auto prefix = lit ? cellular_perception_v12_prefix_bytes
const bool lit = cellular_light_version(wire_version);
const bool liquid = wire_version == session_protocol_v13;
const auto prefix = liquid ? cellular_perception_v13_prefix_bytes
: lit ? cellular_perception_v12_prefix_bytes
: cellular_v10_family(wire_version) && !without_bud_cost
? cellular_perception_v10_prefix_bytes
: wire_version == session_protocol_v9 || without_bud_cost
? cellular_perception_v9_prefix_bytes
: cellular_perception_prefix_bytes;
const bool deposits = cellular_deposit_version(wire_version);
const auto entry =
deposits ? cellular_perceived_deposit_bytes : cellular_perceived_patch_bytes;
const auto entry = liquid ? cellular_perceived_liquid_deposit_bytes
: deposits ? cellular_perceived_deposit_bytes
: cellular_perceived_patch_bytes;
const auto producer_count = lit && payload.size() >= prefix
? static_cast<std::size_t>(get(
payload, cellular_perception_v10_prefix_bytes + 8, 2))
@@ -833,6 +880,14 @@ std::expected<SessionMessage, SessionCodecError> decode_session(std::span<const
}
if (lit)
d.light_pj = get(payload, cellular_perception_v10_prefix_bytes, 8);
if (liquid) {
constexpr auto at = cellular_perception_v12_prefix_bytes;
d.velocity_x_q10 =
static_cast<std::int32_t>(static_cast<std::uint32_t>(get(payload, at, 4)));
d.velocity_y_q10 = static_cast<std::int32_t>(
static_cast<std::uint32_t>(get(payload, at + 4, 4)));
d.heading = static_cast<std::uint16_t>(get(payload, at + 8, 2));
}
}
d.movement = static_cast<CellularMovementResult>(payload[74]);
d.intake = static_cast<CellularIntakeResult>(payload[75]);
@@ -847,7 +902,7 @@ std::expected<SessionMessage, SessionCodecError> decode_session(std::span<const
d.intake != CellularIntakeResult::not_reported ||
d.engulf != CellularEngulfResult::not_reported ||
d.bud != CellularBudOutcome::not_reported || d.bud_cost_energy_pj ||
d.light_pj ||
d.light_pj || d.velocity_x_q10 || d.velocity_y_q10 || d.heading ||
std::ranges::any_of(d.bud_cost_matter_fg,
[](std::uint64_t value) { return value != 0; }))
return std::unexpected(SessionCodecError::invalid_value);
@@ -857,6 +912,29 @@ std::expected<SessionMessage, SessionCodecError> decode_session(std::span<const
return std::unexpected(SessionCodecError::invalid_value);
if (m.diagnostics && !valid_diagnostics(*m.diagnostics))
return std::unexpected(SessionCodecError::invalid_value);
if (liquid) {
constexpr auto at = cellular_perception_v12_prefix_bytes + 10;
const auto flags = payload[at];
CellularCurrentsView c;
c.seed = get(payload, at + 2, 8);
std::array<std::uint32_t, 9> fields{};
for (std::size_t i = 0; i < fields.size(); ++i)
fields.at(i) = static_cast<std::uint32_t>(get(payload, at + 10 + i * 4, 4));
c.width_um = fields[0];
c.height_um = fields[1];
c.pitch_um = fields[2];
c.min_count = fields[3];
c.max_count = fields[4];
c.min_route_width_um = fields[5];
c.max_route_width_um = fields[6];
c.min_speed_um_per_s = fields[7];
c.max_speed_um_per_s = fields[8];
if (flags > 1 || payload[at + 1] != 0 || (flags == 1 && !m.life_identity) ||
(flags == 0 && c != CellularCurrentsView{}))
return std::unexpected(SessionCodecError::invalid_value);
if (flags == 1)
m.currents = c;
}
std::size_t offset = prefix;
if (deposits) {
m.deposits.reserve(count);
@@ -878,6 +956,12 @@ std::expected<SessionMessage, SessionCodecError> decode_session(std::span<const
for (std::size_t c = 0; c < d.amount_codes.size(); ++c)
d.amount_codes.at(c) =
static_cast<std::uint16_t>(get(payload, offset + 16 + c * 2, 2));
if (liquid) {
d.velocity_x_um_s = static_cast<std::int16_t>(
static_cast<std::uint16_t>(get(payload, offset + 26, 2)));
d.velocity_y_um_s = static_cast<std::int16_t>(
static_cast<std::uint16_t>(get(payload, offset + 28, 2)));
}
m.deposits.push_back(d);
}
if (!m.life_identity && producer_count)
@@ -1083,7 +1167,8 @@ encode_cellular_action_input(const CellularActionInput& input) {
: input.engulf ? 2
: input.bud ? 3
: 0);
put(bytes, 0, 3);
bytes.push_back(input.brake ? 1 : 0); // Flags (schema 58): bit 0 brake.
put(bytes, 0, 2);
put(bytes, input.intake_x_um, 4);
put(bytes, input.intake_y_um, 4);
std::array<std::uint8_t, cellular_action_input_bytes> out{};
@@ -1095,7 +1180,7 @@ std::expected<CellularActionInput, SessionCodecError>
decode_cellular_action_input(std::span<const std::uint8_t> bytes) {
if (bytes.size() != cellular_action_input_bytes)
return std::unexpected(SessionCodecError::wrong_length);
if (bytes[12] > 3 || bytes[13] != 0 || bytes[14] != 0 || bytes[15] != 0)
if (bytes[12] > 3 || bytes[13] > 1 || bytes[14] != 0 || bytes[15] != 0)
return std::unexpected(SessionCodecError::invalid_value);
CellularActionInput input;
input.tick = get(bytes, 0, 8);
@@ -1104,6 +1189,7 @@ decode_cellular_action_input(std::span<const std::uint8_t> bytes) {
input.has_intake_target = bytes[12] == 1;
input.engulf = bytes[12] == 2;
input.bud = bytes[12] == 3;
input.brake = bytes[13] == 1;
input.intake_x_um = static_cast<std::uint32_t>(get(bytes, 16, 4));
input.intake_y_um = static_cast<std::uint32_t>(get(bytes, 20, 4));
if (input.tick == 0 ||
+28 -6
View File
@@ -362,6 +362,17 @@ migrate_cellular_photosynthesis_profile(Postgres& db, const FilesystemObjectStor
},
cellular_photosynthesis_upgrade_manifest);
}
std::expected<CommittedCheckpoint, CellularProfileMigrationFailure> migrate_cellular_liquid_profile(
Postgres& db, const FilesystemObjectStore& objects, const LeaseGrant& lease,
const CommittedCheckpoint& predecessor, Uuid commit, const Sha256Digest& build,
const server::CellularLiquidRules& rules, milliseconds timeout, const PublishHooks& hooks) {
return migrate_rules_profile(
db, objects, lease, predecessor, commit, build, timeout, hooks,
[rules](std::span<const std::uint8_t> payload, const CheckpointManifest& previous) {
return cellular_liquid_upgrade_payload(payload, previous, rules);
},
cellular_liquid_upgrade_manifest);
}
std::expected<CommittedCheckpoint, CellularProfileMigrationFailure>
migrate_cellular_profile_to_v2(Postgres& db, const FilesystemObjectStore& objects,
@@ -650,11 +661,13 @@ verify_cellular_no_tick_checkpoint(Postgres& db, const FilesystemObjectStore& ob
const bool maturation = m.cellular_versions == cellular_v11_versions;
const bool inheritance = m.cellular_versions == cellular_v12_versions;
const bool photosynthesis = m.cellular_versions == cellular_v13_versions;
const auto derive = photosynthesis ? cellular_photosynthesis_upgrade_manifest
: inheritance ? cellular_inheritance_upgrade_manifest
: maturation ? cellular_maturation_upgrade_manifest
: boundary ? cellular_boundary_upgrade_manifest
: cellular_profile_migration_manifest;
const bool liquid = m.cellular_versions == cellular_v14_versions;
const auto derive = liquid ? cellular_liquid_upgrade_manifest
: photosynthesis ? cellular_photosynthesis_upgrade_manifest
: inheritance ? cellular_inheritance_upgrade_manifest
: maturation ? cellular_maturation_upgrade_manifest
: boundary ? cellular_boundary_upgrade_manifest
: cellular_profile_migration_manifest;
auto expected = derive(*source, *source_digest, m.commit, recorded, m.build, m.payload_bytes,
m.payload_sha256);
if (!expected || *expected != m)
@@ -662,7 +675,16 @@ verify_cellular_no_tick_checkpoint(Postgres& db, const FilesystemObjectStore& ob
auto bytes = objects.get({source->payload_sha256, source->payload_bytes});
if (!bytes)
return fail(RecoveryError::tail);
if (photosynthesis) {
if (liquid) {
// The declared liquid rules are the upgrade's only input: read them from the target,
// then require the source to re-derive the exact target bytes with them.
auto target = restore_cellular_payload(payload, m);
if (!target)
return fail(RecoveryError::payload);
auto upgraded = cellular_liquid_upgrade_payload(*bytes, *source, (*target)->liquid_rules());
if (!upgraded || !std::ranges::equal(*upgraded, payload))
return fail(RecoveryError::history);
} else if (photosynthesis) {
// The declared light is the upgrade's only input: read it from the target, then
// require the source to re-derive the exact target bytes with it.
auto target = restore_cellular_payload(payload, m);
+27
View File
@@ -224,4 +224,31 @@ cellular_photosynthesis_upgrade_payload(std::span<const std::uint8_t> payload,
return std::unexpected(CheckpointError::payload);
return (*upgraded)->snapshot();
}
std::expected<CheckpointManifest, CheckpointError>
cellular_liquid_upgrade_manifest(const CheckpointManifest& previous,
const Sha256Digest& previous_digest, Uuid commit,
const LeaseGrant& lease, const Sha256Digest& build,
std::uint64_t bytes, const Sha256Digest& digest) {
if (previous.profile != CheckpointProfile::cellular_lives_v1)
return std::unexpected(CheckpointError::unsupported);
return upgrade_manifest(previous, previous_digest, commit, lease, build, bytes, digest,
cellular_v13_versions, cellular_v14_versions);
}
std::expected<std::vector<std::uint8_t>, CheckpointError>
cellular_liquid_upgrade_payload(std::span<const std::uint8_t> payload,
const CheckpointManifest& previous,
const server::CellularLiquidRules& rules) {
if (!supported(previous) || previous.profile != CheckpointProfile::cellular_lives_v1 ||
previous.cellular_versions != cellular_v13_versions)
return std::unexpected(CheckpointError::unsupported);
if (!encode_manifest(previous) || previous.sequence == 0 || previous.end_tick == 0)
return std::unexpected(CheckpointError::chain);
auto state = restore_cellular_payload(payload, previous);
if (!state)
return std::unexpected(state.error());
auto upgraded = (*state)->liquid_upgrade_candidate(rules);
if (!upgraded)
return std::unexpected(CheckpointError::payload);
return (*upgraded)->snapshot();
}
} // namespace evo::persistence
+3 -2
View File
@@ -105,7 +105,8 @@ bool valid_action_input(const CellularActionRecord& action, std::uint64_t begin_
return !all_zero(action.account) && action.action_id != 0 && tick > begin_tick &&
tick <= end_tick && move_x >= -movement_limit && move_x <= movement_limit &&
move_y >= -movement_limit && move_y <= movement_limit && input[12] <= 3 &&
all_zero(input.subspan(13, 3)) && (input[12] == 1 || all_zero(input.subspan(16, 8)));
input[13] <= 1 && all_zero(input.subspan(14, 2)) &&
(input[12] == 1 || all_zero(input.subspan(16, 8)));
}
bool action_less(const CellularActionRecord& a, const CellularActionRecord& b) {
const auto a_tick = action_tick(a);
@@ -575,7 +576,7 @@ match_cellular_actions_to_trace(const CellularLives& predecessor, const Cellular
intent->intent.movement.y !=
std::bit_cast<std::int16_t>(static_cast<std::uint16_t>(get(input, 10, 2))) ||
intent->intent.intake_target != target || intent->intent.engulf != (input[12] == 2) ||
intent->intent.bud != (input[12] == 3))
intent->intent.bud != (input[12] == 3) || intent->intent.brake != (input[13] == 1))
return std::unexpected{CellularActionBlockError::mismatch};
}
return {};
@@ -76,6 +76,8 @@ prepare_cellular_session_tick(const CellularLives& state, std::uint64_t tick,
owned_intent->intent.engulf = input->engulf;
// ADR-0125: below rules 4 the owner ignores a bud intent.
owned_intent->intent.bud = input->bud;
// Rules 12: below them the owner refuses a brake, so only v13 sessions send one.
owned_intent->intent.brake = input->brake;
CellularActionRecord record;
record.account = action.account.bytes;
record.action_id = action.action_id;
+14 -3
View File
@@ -628,7 +628,7 @@ struct RegionSessions::Impl {
wire_version == network::session_protocol_v9 ||
network::cellular_v10_family(wire_version)) &&
!cellular_actions) ||
wire_version > network::session_protocol_v12)
wire_version > network::session_protocol_v13)
return close(c, SessionCloseReason::unsupported_version, now);
} else if (wire_version != c.protocol_version) {
return close(c, SessionCloseReason::unsupported_version, now);
@@ -954,12 +954,23 @@ bool RegionSessions::send_cellular_perception(const network::AccountId& account,
delivered.patches.clear();
else
delivered.deposits.clear();
// Only v12 carries captured light and visible producers (ADR-0176).
if (c.protocol_version != network::session_protocol_v12) {
// Only v12 and v13 carry captured light and visible producers (ADR-0176).
if (!network::cellular_light_version(c.protocol_version)) {
delivered.producers.clear();
if (delivered.diagnostics)
delivered.diagnostics->light_pj = 0;
}
// Only v13 carries liquid motion (rules 12).
if (c.protocol_version != network::session_protocol_v13) {
delivered.currents.reset();
if (delivered.diagnostics) {
delivered.diagnostics->velocity_x_q10 = 0;
delivered.diagnostics->velocity_y_q10 = 0;
delivered.diagnostics->heading = 0;
}
for (auto& deposit : delivered.deposits)
deposit.velocity_x_um_s = deposit.velocity_y_um_s = 0;
}
if (c.protocol_version == network::session_protocol_v8)
delivered.diagnostics.reset();
if (c.protocol_version == network::session_protocol_v9 && delivered.diagnostics) {
+67 -1
View File
@@ -110,9 +110,14 @@ void v7_reliable_action_is_stable_and_strict() {
auto malformed_input = canonical;
malformed_input[12] = 2;
CHECK(!decode_cellular_action_input(malformed_input));
// Byte 13 is a flags byte (schema 58): bit 0 brake, every other bit refused.
malformed_input = canonical;
malformed_input[13] = 1;
malformed_input[13] = 2;
CHECK(!decode_cellular_action_input(malformed_input));
auto braking_input = canonical;
braking_input[13] = 1;
const auto braking = decode_cellular_action_input(braking_input);
CHECK(braking && braking->brake && encode_cellular_action_input(*braking) == braking_input);
malformed_input = canonical;
// The canonical biological input itself requires a nonzero tick.
std::fill(malformed_input.begin(), malformed_input.begin() + 8, std::uint8_t{0});
@@ -542,6 +547,66 @@ void v12_perception_carries_light_and_producers() {
CHECK(encode_session(SessionMessage{offer}, session_protocol_v12).empty());
}
// Rules 12: v13 is v12 plus liquid motion: the owner's velocity and heading and the region's
// current configuration in its view, each deposit's world velocity, and a brake on actions.
// Earlier versions refuse every liquid field.
void v13_perception_carries_liquid_motion() {
CellularLifeDiagnostics d;
d.reserve_energy_pj = 9;
d.light_pj = 3;
d.velocity_x_q10 = -190 * 1'024;
d.velocity_y_q10 = 12;
d.heading = 49'152;
CellularPerception view{77, 7, {}, d};
CellularPerceivedDeposit bubble{9, 9'000, 400, 30, CellularDepositShape::bubble,
false, {1, 0, 0, 4, 0}};
bubble.velocity_x_um_s = -250;
bubble.velocity_y_um_s = 60;
view.deposits.push_back(bubble);
view.currents = CellularCurrentsView{5, 60'000, 60'000, 250, 2, 4, 3'000, 6'000, 60, 300};
const auto bytes = encode_session(SessionMessage{view}, session_protocol_v13);
CHECK(bytes.size() == session_header_bytes + 18 + 64 + 40 + 16 + 56 + 30);
std::uint16_t version{};
const auto decoded = decode_session(bytes, &version);
CHECK(decoded && version == session_protocol_v13 &&
std::get<CellularPerception>(*decoded) == view);
// v12 has room for none of it.
CHECK(encode_session(SessionMessage{view}, session_protocol_v12).empty());
auto still = view;
still.currents.reset();
still.diagnostics->velocity_x_q10 = still.diagnostics->velocity_y_q10 = 0;
still.diagnostics->heading = 0;
still.deposits[0].velocity_x_um_s = still.deposits[0].velocity_y_um_s = 0;
CHECK(!encode_session(SessionMessage{still}, session_protocol_v12).empty());
// A region without currents sends a v13 view with the liquid flag clear.
CHECK(std::get<CellularPerception>(*decode_session(
encode_session(SessionMessage{still}, session_protocol_v13))) == still);
// The flag is 0 or 1, the reserved byte zero, and a cleared view carries no currents.
constexpr std::size_t flags = session_header_bytes + 18 + 64 + 40 + 16 + 10;
auto bad = bytes;
bad[flags] = 2;
CHECK(!decode_session(bad));
bad = bytes;
bad[flags + 1] = 1;
CHECK(!decode_session(bad));
auto cleared = still;
cleared.life_identity = 0;
cleared.diagnostics.reset();
cleared.deposits.clear();
cleared.currents = view.currents;
CHECK(encode_session(SessionMessage{cleared}, session_protocol_v13).empty());
// A brake travels only on v13 actions.
CellularAction braking{1, 2, 3, 4, 500, 0, false, 0, 0};
braking.brake = true;
const auto action = encode_session(SessionMessage{braking}, session_protocol_v13);
CHECK(std::get<CellularAction>(*decode_session(action)) == braking);
auto old_brake = encode_session(SessionMessage{CellularAction{1, 2, 3, 4, 500, 0, false, 0, 0}},
session_protocol_v12);
old_brake[session_header_bytes + 37] = 1;
CHECK(!decode_session(old_brake));
}
int main() {
try {
round_trip_and_version_gate();
@@ -556,6 +621,7 @@ int main() {
v10_effects_and_life_end_are_owner_only();
v11_perception_carries_deposits();
v12_perception_carries_light_and_producers();
v13_perception_carries_liquid_motion();
std::puts(
"PASS cellular protocol: v6 intention, v7 action, v8-v10 perception/action framing");
} catch (const std::exception& error) {
+1 -1
View File
@@ -15,7 +15,7 @@ using namespace evo::fixture;
constexpr biology::CellularArea area{48'000, 48'000};
CellularLiquidRules rules(std::uint64_t seed = 5) {
return {.currents = {seed, area.width_um, area.height_um, 250, 2, 4, 3'000, 6'000, 60, 300},
return {.currents = {seed, 48'000, 48'000, 250, 2, 4, 3'000, 6'000, 60, 300},
.founder = {.thrust_q10 = 20'480,
.reverse_thrust_q10 = 20'480,
.forward_drag_ppm = 95'163,
+8
View File
@@ -126,7 +126,15 @@ void file_format() {
CHECK(refused(parse_bindings("move_up W\n"), BindingError::malformed));
CHECK(refused(parse_bindings("evo-controls 2\n"), BindingError::unsupported_version));
CHECK(refused(parse_bindings("evo-controls 1 extra\n"), BindingError::malformed));
// Original actions stay required; one added later (brake) takes its default key when it
// is free, and is refused when another action already holds it.
CHECK(refused(parse_bindings(without("pan_down")), BindingError::missing_primary));
CHECK(parse_bindings(without("brake")) == *custom);
auto held = without("brake");
const auto left = held.find("move_left A\n");
CHECK(left != std::string::npos);
held.replace(left, 12, "move_left A Space\n");
CHECK(refused(parse_bindings(held), BindingError::missing_primary));
CHECK(refused(parse_bindings(text + "move_up W\n"), BindingError::malformed));
CHECK(refused(parse_bindings(text + "jump Space\n"), BindingError::malformed));
CHECK(refused(parse_bindings(without("move_up") + "move_up w\n"), BindingError::malformed));
+1 -1
View File
@@ -371,7 +371,7 @@ void session_codec() {
mutated.at(0) ^= 1;
CHECK(refused(decode_session(mutated), SessionCodecError::bad_magic));
mutated = bytes;
mutated.at(4) = 13; // A future version; protocol versions through 12 are supported.
mutated.at(4) = 14; // A future version; protocol versions through 13 are supported.
CHECK(refused(decode_session(mutated), SessionCodecError::unsupported_version));
mutated = bytes;
mutated.at(7) = 1;
+2 -1
View File
@@ -223,6 +223,7 @@ void upgrade_across_migration_and_barrier() {
" -v migration_sha_55=$(s 0055_retained_cellular_plans.sql)"
" -v migration_sha_56=$(s 0056_cellular_environment_publication.sql)"
" -v migration_sha_57=$(s 0057_photosynthesis_bundle.sql)"
" -v migration_sha_58=$(s 0058_liquid_bundle.sql)"
" -v runtime_role=evo_runtime_test -f migrations/apply.sql"
" > /dev/null 2>&1") != 0);
CHECK(history(*owner_db) == "1,2,3,4,5,6,7");
@@ -240,7 +241,7 @@ void upgrade_across_migration_and_barrier() {
"tools/migrate-postgres.sh\" > /dev/null") == 0);
CHECK(history(*owner_db) == "1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,"
"25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,"
"47,48,49,50,51,52,53,54,55,56,57");
"47,48,49,50,51,52,53,54,55,56,57,58");
CHECK(scalar(*owner_db, "SELECT (c.condeferrable AND c.condeferred AND "
"c.confrelid = 'evolution.region_commits'::regclass)::text "
"FROM pg_catalog.pg_constraint c WHERE c.conrelid = "
+123
View File
@@ -2,6 +2,7 @@
// the object volume's free-space reserve, a genuinely failing write, the
// check-store probe (retention across runs, missing-volume refusal, privilege
// boundary) and a server whose volume is full. Run by tools/ci/postgres-check.sh.
#include "evo/biology/cellular_tuning.hpp"
#include "evo/persistence/account_control_store.hpp"
#include "evo/persistence/checkpoint_store.hpp"
#include "evo/persistence/region_checkpoint.hpp"
@@ -13,6 +14,7 @@
#include "fixtures/server_process.hpp"
#include <algorithm>
#include <csignal>
#include <fstream>
#include <source_location>
#include <sys/resource.h>
@@ -753,6 +755,126 @@ void cellular_v8_provisioning_declares_light() {
#endif
}
// Rules 12 (ADR-0177): cellular-v9 is cellular-v8 followed by the 13 -> 14 liquid upgrade from
// the Git tuning file, whose region size must match the opening; resumable and idempotent.
void cellular_v9_provisioning_declares_liquid() {
const ServerRegion r{{9777, 1}, fresh("cellular-v9-provision-9777")};
const std::string build(64, 'e');
const std::string commit = "b0b81e5c0f7e1d2ba1a0ce5c0f7e1d2e"; // Unique to this test.
const std::string motes = "40,1,2000000,50000,20000,0,0";
const auto write_tuning = [&](std::uint32_t side) {
auto parsed = evo::biology::parse_cellular_tuning(
"tuning.version = 1\nregion.width_um = 60000\nregion.height_um = 60000\n"
"region.organism_cap = 2000\nregion.deposit_limit = 8192\n"
"region.perception_radius_um = 5000\nfounder.thrust_um_per_s2 = 400\n"
"founder.reverse_thrust_um_per_s2 = 400\nfounder.drag_ppm_per_tick = 95163\n"
"founder.lateral_drag_ppm_per_tick = 95163\nfounder.turn_heading_per_s = 65536\n"
"currents.min_count = 2\ncurrents.max_count = 4\ncurrents.min_width_um = 3000\n"
"currents.max_width_um = 6000\ncurrents.min_speed_um_per_s = 60\n"
"currents.max_speed_um_per_s = 300\ncurrents.grid_pitch_um = 250\n"
"food.merged_bubble_cap_multiple = 8\nfood.visible_moving_bubbles = 256\n"
"food.induced_drift_radius_um = 200\nfood.induced_drift_max_um_per_s = 100\n"
"food.induced_drift_decay_ppm_per_tick = 95163\nthermal.ambient_min_mk = 278150\n"
"thermal.ambient_max_mk = 313150\nfounder.preferred_mk = 293150\n"
"founder.comfort_band_mk = 5000\nfounder.body_tau_ms = 20000\n"
"founder.lethal_cold_mk = 273150\nfounder.lethal_heat_mk = 318150\n"
"thermal.off_preference_per_mille_per_k = 80\n"
"thermal.transition_per_mille_per_k = 40\nthermal.multiplier_cap_per_mille = 8000\n"
"lifecycle.logout_delay_ms = 10000\nmutation.step_points = 5\n"
"mutation.paired_points = 2\nmutation.recovery_floor_per_mille = 100\n"
"mutation.offer_interval_ms = 25000\nmutation.offer_options = 3\n");
CHECK(parsed);
parsed->region_width_um = parsed->region_height_um = side;
const auto path = r.root / ("cellular-" + std::to_string(side) + ".tuning");
std::ofstream{path, std::ios::binary} << evo::biology::encode_cellular_tuning(*parsed);
return path.string();
};
int code = -1;
provision_cellular(r, "9777", "cellular-v9", build, commit, motes, code, "--motes",
{"--light-pj", "40"});
CHECK(code != 0); // cellular-v9 requires --tuning.
provision_cellular(r, "9777", "cellular-v9", build, commit, motes, code, "--motes",
{"--light-pj", "40", "--tuning", write_tuning(20'000)});
CHECK(code != 0); // The tuning region size must match the opening's.
const auto tuning = write_tuning(10'000);
const auto first = provision_cellular(r, "9777", "cellular-v9", build, commit, motes, code,
"--motes", {"--light-pj", "40", "--tuning", tuning});
CHECK(code == 0 && has(first, "provisioned world=9777 region=1 sequence=6 tick=1"));
const auto again = provision_cellular(r, "9777", "cellular-v9", build, commit, motes, code,
"--motes", {"--light-pj", "40", "--tuning", tuning});
CHECK(code == 0 && has(again, "already-provisioned world=9777 region=1 sequence=6 tick=1"));
auto db = owner();
const auto head = load_region_checkpoint(*db, r.key, 5s);
CHECK(head);
const auto manifest = decode_manifest(head->manifest);
CHECK(manifest && manifest->cellular_versions == cellular_v14_versions &&
manifest->history_profile == cellular_revision_history_profile);
#ifdef EVO_POSTGRES_M10
// A player is born on the liquid head and swims and brakes through the live server path:
// host reservation, session batch builder, host publication with a braking trace.
using namespace evo::server;
const auto connect = [&]() -> std::expected<std::unique_ptr<Postgres>, PgFailure> {
return Postgres::connect({env("PGHOST"),
{},
env("PGPORT"),
env("PGDATABASE"),
env("EVO_PG_RUNTIME_USER"),
{},
{}},
5s);
};
CHECK(db->query("INSERT INTO evolution.life_allocators VALUES(9777,1000)", {}, 5s));
Sha256Digest digest{};
digest.fill(0xEE);
auto objects = FilesystemObjectStore::open(r.root, r.key, max_cellular_lives_bytes);
CHECK(objects);
auto made =
CellularRegionHost::create({r.key, 9, {}, digest, {digest}}, connect, std::move(*objects));
CHECK(made);
auto host = std::move(*made);
CHECK(host->step().ready && host->state() &&
host->state()->rules_version() == cellular_lives_liquid_rules &&
host->state()->flow_field() != nullptr);
auto runtime = connect();
CHECK(runtime);
Uuid account{};
account[0] = 0x9E;
account.back() = 0x14;
const auto control =
claim_account_control(**runtime, r.key, *host->authority(), account, 1, 1, 20'000ms, 5s);
CHECK(control);
CHECK(host->create_primitive_life(account, control->generation, 5).result ==
evo::network::PrimitiveLifeResult::pending);
const std::vector births(host->queued_births().begin(), host->queued_births().end());
auto builder = CellularSessionBatchBuilder::create(*host->state(), host->committed()->head);
CHECK(builder);
CHECK(builder->append_with_birth_refusals(host->state()->tick() + 1, {}, {}, births, {}));
CHECK(builder->refused_births().empty() &&
builder->batch().format_version == cellular_batch_inheritance_format);
CHECK(host->publish(builder->batch(), builder->actions(), builder->mutation_actions()));
CHECK(host->query_primitive_life(account, control->generation, 5).result ==
evo::network::PrimitiveLifeResult::born);
// Ticks of swimming then braking publish and leave the founder in motion state.
for (int tick = 0; tick < 6; ++tick) {
std::vector<CellularLifeIntent> intents;
for (const auto& life : host->state()->lives()) {
CellularLifeIntent intent{life.identity.life, {}};
intent.intent.movement = {1'000, 0};
intent.intent.brake = tick >= 4;
intents.push_back(intent);
}
std::ranges::sort(intents, {}, &CellularLifeIntent::life_id);
auto next = CellularSessionBatchBuilder::create(*host->state(), host->committed()->head);
CHECK(next && next->append(host->state()->tick() + 1, intents, {}));
CHECK(host->publish(next->batch(), next->actions(), next->mutation_actions()));
}
CHECK(host->state()->lives().front().identity.genome != 0);
const auto genome =
host->state()->archive().find(host->state()->lives().front().identity.genome);
CHECK(genome && genome->schema_version() == evo::biology::genome_schema_v6);
#endif
}
#ifdef EVO_POSTGRES_M10
// A player on a cellular-v8 region feeds by contact until offered a mutation, chooses it
// and publishes the choice, all through the host and session builder as evo-server does.
@@ -884,6 +1006,7 @@ void run_region_store_tests() {
cellular_v6_provisioning_uses_the_reproduction_bundle();
cellular_v7_provisioning_scatters_bubbles();
cellular_v8_provisioning_declares_light();
cellular_v9_provisioning_declares_liquid();
#ifdef EVO_POSTGRES_M10
cellular_v8_player_chooses_a_mutation();
#endif
+10 -1
View File
@@ -58,7 +58,7 @@ for invalid in NULL "'00000000-0000-0000-0000-000000000000'"; do
done
# Reconstruct the exact pre-context metadata schema in this disposable database.
# Restore the resulting real legacy backup through both supported workflows.
# Undo schema 57's bundle-13 wrappers, schema 56's joint profile, schema 55's plan validators, schema 54's three
# Undo schema 58's bundle-14 wrappers, schema 57's bundle-13 wrappers, schema 56's joint profile, schema 55's plan validators, schema 54's three
# replacements and schema 53; the backup must contain the actual pre-context
# function contracts and privileges.
awk '/^CREATE FUNCTION evolution\.admit_population_interval\(/ {capture=1; sub(/^CREATE FUNCTION/,"CREATE OR REPLACE FUNCTION")} capture {print} capture && /^END \$\$;/ {capture=0}' \
@@ -68,8 +68,17 @@ awk '/^CREATE FUNCTION evolution\.(check_cellular_migration_trace|prepare_cellul
"$root/migrations/0049_cellular_migration_publication.sql" | sql > /dev/null
awk '/^CREATE OR REPLACE FUNCTION evolution\.(cellular_mutation_selections|check_cellular_mutation_block)\(/ {capture=1} capture {print} capture && /^END \$\$;/ {capture=0}' \
"$root/migrations/0040_cellular_mutation_decline.sql" | sql > /dev/null
# Schema 58 widened the canonical action input; restore schema 36's validator.
awk '/^CREATE OR REPLACE FUNCTION evolution\.valid_cellular_action_input\(/ {capture=1} capture {print} capture && /^END \$\$;/ {capture=0}' \
"$root/migrations/0036_cellular_v5_budding_bundle.sql" | sql > /dev/null
sql -v runtime_role="$EVO_PG_RUNTIME_ROLE" > /dev/null <<'SQL'
DROP FUNCTION evolution.publish_cellular_profile_migration(bytea);
ALTER FUNCTION evolution.publish_cellular_profile_migration_v57(bytea) RENAME TO publish_cellular_profile_migration;
DROP FUNCTION evolution.cellular_births(bytea,bytea);
ALTER FUNCTION evolution.cellular_births_v57(bytea,bytea) RENAME TO cellular_births;
DROP FUNCTION evolution.parse_checkpoint_manifest(bytea);
ALTER FUNCTION evolution.parse_checkpoint_manifest_v57(bytea) RENAME TO parse_checkpoint_manifest;
DROP FUNCTION evolution.publish_cellular_profile_migration(bytea);
ALTER FUNCTION evolution.publish_cellular_profile_migration_v56(bytea) RENAME TO publish_cellular_profile_migration;
DROP FUNCTION evolution.cellular_births(bytea,bytea);
ALTER FUNCTION evolution.cellular_births_v56(bytea,bytea) RENAME TO cellular_births;
+5 -5
View File
@@ -161,7 +161,7 @@ PGDATABASE=upgrade_path psql -X -v ON_ERROR_STOP=1 -1 -v "migration_sha=$v1_sha"
-f "$root/migrations/0001_region_bootstrap.sql" > /dev/null
test "$(PGDATABASE=upgrade_path psql -XAtc "SELECT string_agg(version::text, ',') FROM evolution.schema_migrations")" = 1
PGDATABASE=upgrade_path bash "$root/tools/migrate-postgres.sh"
test "$(PGDATABASE=upgrade_path psql -XAtc "SELECT string_agg(version::text, ',' ORDER BY version) FROM evolution.schema_migrations")" = 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57
test "$(PGDATABASE=upgrade_path psql -XAtc "SELECT string_agg(version::text, ',' ORDER BY version) FROM evolution.schema_migrations")" = 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58
# v2 heads have no payload binding: v2->v3 fails closed and leaves history at v2.
v2_sha="$(sha256sum "$root/migrations/0002_region_fencing.sql")"
v2_sha="${v2_sha%% *}"
@@ -182,7 +182,7 @@ PGDATABASE=v3_commits psql -X -v ON_ERROR_STOP=1 \
-c "INSERT INTO evolution.retained_builds VALUES (decode(repeat('b1', 32), 'hex'))" \
-c "SELECT evolution.provision_region_checkpoint(decode('4145564f52434d31' || '01000000' || '01000000' || '0100000000000000' || '0100000000000000' || '0900000000000000' || repeat('11', 16) || repeat('00', 8) || repeat('00', 16) || repeat('00', 32) || repeat('00', 16) || repeat('00', 16) || repeat('00', 8) || '50c3000000000000' || '020000000200000001000000010000000100000001000000010000000100000001000000' || repeat('b1', 32) || '00000000' || '00000000' || '01000000' || '6400000000000000' || repeat('a0', 32), 'hex'))" > /dev/null
PGDATABASE=v3_commits bash "$root/tools/migrate-postgres.sh"
test "$(PGDATABASE=v3_commits psql -XAtc "SELECT count(*) || ':' || string_agg(version::text, ',' ORDER BY version) FROM evolution.schema_migrations")" = 57:1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57
test "$(PGDATABASE=v3_commits psql -XAtc "SELECT count(*) || ':' || string_agg(version::text, ',' ORDER BY version) FROM evolution.schema_migrations")" = 58:1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58
test "$(PGDATABASE=v3_commits psql -XAtc "SELECT count(*) FROM evolution.region_commits")" = 1
# Review P1: a v4 database holding a published (possibly terminal) checkpoint has
# no durable decisions for it. The v5 upgrade must refuse before changing anything.
@@ -236,7 +236,7 @@ PGDATABASE=v6_populated psql -X -v ON_ERROR_STOP=1 \
-c "INSERT INTO evolution.retained_builds VALUES (decode(repeat('b1', 32), 'hex'))" \
-c "SELECT evolution.provision_region_checkpoint(decode('4145564f52434d31' || '02000000' || '01000000' || '0100000000000000' || '0100000000000000' || '0900000000000000' || repeat('11', 16) || repeat('00', 8) || repeat('00', 16) || repeat('00', 32) || repeat('00', 16) || repeat('00', 16) || repeat('00', 8) || '50c3000000000000' || '020000000200000001000000010000000100000001000000010000000100000001000000' || repeat('b1', 32) || '00000000' || '00000000' || '01000000' || '6400000000000000' || repeat('a0', 32) || repeat('00', 80), 'hex'))" > /dev/null
PGDATABASE=v6_populated bash "$root/tools/migrate-postgres.sh"
test "$(PGDATABASE=v6_populated psql -XAtc "SELECT string_agg(version::text, ',' ORDER BY version) FROM evolution.schema_migrations")" = 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57
test "$(PGDATABASE=v6_populated psql -XAtc "SELECT string_agg(version::text, ',' ORDER BY version) FROM evolution.schema_migrations")" = 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58
test "$(PGDATABASE=v6_populated psql -XAtc "SELECT count(*) FROM evolution.region_commits c, LATERAL evolution.parse_checkpoint_manifest(c.manifest) m WHERE m.commit_sequence = 0 AND m.predecessor_commit IS NULL")" = 1
test "$(PGDATABASE=v6_populated psql -XAtc "SELECT string_agg(conname, ',') FROM pg_constraint WHERE conrelid = 'evolution.region_heads'::regclass AND contype = 'c' AND pg_get_constraintdef(oid) LIKE '%end_tick%'")" = region_heads_published_tick
phase permission-audit
@@ -294,9 +294,9 @@ expect_audit_failure 'REVOKE EXECUTE ON FUNCTION evolution.load_world_cellular_m
expect_audit_failure 'GRANT EXECUTE ON FUNCTION evolution.fork_restored_history_v1(uuid) TO evo_runtime_test' 'REVOKE EXECUTE ON FUNCTION evolution.fork_restored_history_v1(uuid) FROM evo_runtime_test'
phase checksum-drift
# Unknown future versions and checksum drift must not be repaired silently.
psql -X -v ON_ERROR_STOP=1 -c 'UPDATE evolution.schema_migrations SET version=58 WHERE version=57'
psql -X -v ON_ERROR_STOP=1 -c 'UPDATE evolution.schema_migrations SET version=59 WHERE version=58'
if bash "$root/tools/migrate-postgres.sh"; then exit 1; fi
psql -X -v ON_ERROR_STOP=1 -c "UPDATE evolution.schema_migrations SET version=57 WHERE version=58"
psql -X -v ON_ERROR_STOP=1 -c "UPDATE evolution.schema_migrations SET version=58 WHERE version=59"
psql -X -v ON_ERROR_STOP=1 -c "UPDATE evolution.schema_migrations SET sha256=repeat('0',64) WHERE version=14"
if bash "$root/tools/migrate-postgres.sh"; then exit 1; fi
psql -X -v ON_ERROR_STOP=1 -c "UPDATE evolution.schema_migrations SET sha256=repeat('0',64) WHERE version=13"
+3 -1
View File
@@ -126,6 +126,8 @@ digest_56="$(sha256sum "$root/migrations/0056_cellular_environment_publication.s
digest_56="${digest_56%% *}"
digest_57="$(sha256sum "$root/migrations/0057_photosynthesis_bundle.sql")"
digest_57="${digest_57%% *}"
digest_58="$(sha256sum "$root/migrations/0058_liquid_bundle.sql")"
digest_58="${digest_58%% *}"
psql -X --no-password --set=ON_ERROR_STOP=1 --set="migration_sha=$digest" \
--set="migration_sha_2=$digest_2" --set="migration_sha_3=$digest_3" \
--set="migration_sha_4=$digest_4" --set="migration_sha_5=$digest_5" \
@@ -173,6 +175,6 @@ psql -X --no-password --set=ON_ERROR_STOP=1 --set="migration_sha=$digest" \
--set="migration_sha_52=$digest_52" \
--set="migration_sha_53=$digest_53" --set="migration_sha_54=$digest_54" \
--set="migration_sha_55=$digest_55" --set="migration_sha_56=$digest_56" \
--set="migration_sha_57=$digest_57" \
--set="migration_sha_57=$digest_57" --set="migration_sha_58=$digest_58" \
--set="runtime_role=$runtime_role" \
--file="$root/migrations/apply.sql"