Files
aevolution/migrations/0037_cellular_life_endings.sql
dingoandClaude Opus 5.5 4130092d7a End dead lives durably so a player can start again
M11.6a (ADR-0127, schema v37): a published life is marked ended once, by a
commit of its region, through the lease-fenced end_cellular_lives. One active
life per account replaces one life per account, so after a death the account
reserves and publishes a new primitive founder while the corpse, archive and
descendants stay. The host records endings after the death's publication and
again for every founder corpse on recovery. The cellular server now refuses only
an unusable carried action, not the whole tick.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-14 07:26:33 -04:00

203 lines
11 KiB
PL/PgSQL

-- M11.6, ADR-0127: permadeath and a complete restart. A life's reservation is marked
-- ended, once and forever, by the region that holds its commit; an account may then
-- reserve and publish a new founder. One ACTIVE life per account replaces one life
-- per account. Corpses, archives, descendants and every earlier row stay unchanged.
ALTER TABLE evolution.life_reservations ADD COLUMN ended_commit uuid;
DROP INDEX evolution.one_reserved_life_per_account;
CREATE UNIQUE INDEX one_active_life_per_account
ON evolution.life_reservations(world_id, account_id)
WHERE rejection = 0 AND ended_commit IS NULL;
-- A published binding no longer implies the account's only life.
ALTER TABLE evolution.primitive_life_bindings
DROP CONSTRAINT primitive_life_bindings_world_id_account_id_key;
-- An ending is set once, only on a published, unrefused life, and never undone.
CREATE FUNCTION evolution.life_ending_is_final() RETURNS trigger
LANGUAGE plpgsql SECURITY INVOKER SET search_path = pg_catalog, pg_temp AS $$
BEGIN
IF OLD.ended_commit IS NOT NULL AND NEW.ended_commit IS DISTINCT FROM OLD.ended_commit THEN
RAISE EXCEPTION 'life ending is final' USING ERRCODE = 'EVL16';
END IF;
IF NEW.ended_commit IS NOT NULL AND OLD.ended_commit IS NULL
AND (NEW.rejection <> 0 OR NOT EXISTS (SELECT 1 FROM evolution.primitive_life_bindings b
WHERE b.world_id = NEW.world_id AND b.account_id = NEW.account_id
AND b.request_id = NEW.request_id)) THEN
RAISE EXCEPTION 'only a published life can end' USING ERRCODE = 'EVL16';
END IF;
RETURN NEW;
END $$;
CREATE TRIGGER life_ending_is_final BEFORE UPDATE OF ended_commit
ON evolution.life_reservations FOR EACH ROW EXECUTE FUNCTION evolution.life_ending_is_final();
-- Unchanged from schema v17 except that an ended life no longer blocks a new request.
CREATE OR REPLACE FUNCTION evolution.reserve_primitive_life(p_world evolution.u64,
p_region evolution.u64, p_holder uuid, p_epoch evolution.u64, p_account uuid,
p_generation evolution.u64, p_request evolution.u64, p_rules integer)
RETURNS TABLE (life_identity evolution.u64, life_region evolution.u64, rejection smallint)
LANGUAGE plpgsql SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS $$
DECLARE r evolution.life_reservations%ROWTYPE; allocated numeric;
BEGIN
IF p_request IS NULL OR p_request = 0 OR p_rules IS DISTINCT FROM 1 THEN
RAISE EXCEPTION 'invalid life request' USING ERRCODE = '22023';
END IF;
PERFORM evolution.check_life_control(p_world, p_region, p_holder, p_epoch, p_account, p_generation);
SELECT * INTO r FROM evolution.life_reservations x
WHERE x.world_id = p_world AND x.account_id = p_account AND x.request_id = p_request;
IF FOUND THEN
RETURN QUERY SELECT r.identity, r.region_id, r.rejection;
RETURN;
END IF;
SELECT a.next_identity INTO allocated FROM evolution.life_allocators a
WHERE a.world_id = p_world FOR UPDATE;
IF NOT FOUND THEN
RAISE EXCEPTION 'life allocator not provisioned' USING ERRCODE = 'EVL04';
END IF;
IF allocated = 18446744073709551615 THEN
RAISE EXCEPTION 'life identities exhausted' USING ERRCODE = 'EVL05';
END IF;
PERFORM evolution.check_life_control(p_world, p_region, p_holder, p_epoch, p_account, p_generation);
IF EXISTS (SELECT 1 FROM evolution.life_reservations x
WHERE x.world_id = p_world AND x.account_id = p_account AND x.rejection = 0
AND x.ended_commit IS NULL) THEN
UPDATE evolution.life_allocators SET next_identity = allocated + 1 WHERE world_id = p_world;
INSERT INTO evolution.life_reservations(world_id, account_id, request_id, identity,
region_id, rules, rejection)
VALUES (p_world, p_account, p_request, allocated, p_region, p_rules, 4);
RETURN QUERY SELECT allocated::evolution.u64, p_region, 4::smallint;
RETURN;
END IF;
UPDATE evolution.life_allocators SET next_identity = allocated + 1 WHERE world_id = p_world;
INSERT INTO evolution.life_reservations(world_id, account_id, request_id, identity, region_id, rules)
VALUES (p_world, p_account, p_request, allocated, p_region, p_rules);
RETURN QUERY SELECT allocated::evolution.u64, p_region, 0::smallint;
END $$;
-- Unchanged from schema v24 except that only the active life has an owner region.
CREATE OR REPLACE FUNCTION evolution.primitive_life_owner(p_world evolution.u64,
p_region evolution.u64, p_holder uuid, p_epoch evolution.u64, p_account uuid)
RETURNS TABLE (owner_region evolution.u64)
LANGUAGE plpgsql SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS $$
BEGIN
IF p_world IS NULL OR p_world = 0 OR p_region IS NULL OR p_region = 0
OR p_holder IS NULL OR p_epoch IS NULL OR p_epoch = 0
OR p_account IS NULL OR p_account = '00000000-0000-0000-0000-000000000000' THEN
RAISE EXCEPTION 'invalid life owner lookup' USING ERRCODE = '22023';
END IF;
PERFORM evolution.check_region_lease(p_world, p_region, p_holder, p_epoch);
RETURN QUERY SELECT r.region_id FROM evolution.life_reservations r
WHERE r.world_id = p_world AND r.account_id = p_account AND r.rejection = 0
AND r.ended_commit IS NULL;
END $$;
-- Unchanged from schema v31 (renamed in v35) except that only an active binding of the
-- account conflicts with a new birth.
CREATE OR REPLACE FUNCTION evolution.publish_cellular_birth_checkpoint(p_manifest bytea,
p_decisions bytea, p_actions bytea, p_trace 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);
birth_row record;
r evolution.life_reservations%ROWTYPE;
BEGIN
IF c.profile <> 4 OR c.commit_sequence = 0 OR p_actions IS NULL THEN
RAISE EXCEPTION 'invalid cellular publication' USING ERRCODE = '22023';
END IF;
PERFORM evolution.check_cellular_action_block(p_actions, c.begin_tick, c.end_tick);
PERFORM * FROM evolution.cellular_births(p_trace, p_manifest);
IF EXISTS (SELECT b.account_id FROM evolution.cellular_births(p_trace, p_manifest) b
GROUP BY b.account_id HAVING count(*) > 1)
OR EXISTS (SELECT b.identity FROM evolution.cellular_births(p_trace, p_manifest) b
GROUP BY b.identity HAVING count(*) > 1) THEN
RAISE EXCEPTION 'duplicate cellular birth identity' USING ERRCODE = '22023';
END IF;
PERFORM evolution.check_region_lease(c.world_id, c.region_id, c.holder, c.epoch);
-- The lease lock fences competing commits. Exact retries are accepted only
-- when the immutable binding rows agree with every birth in the trace.
IF EXISTS (SELECT 1 FROM evolution.region_commits x WHERE x.commit_id = c.commit_id) THEN
IF NOT evolution.cellular_birth_bindings_match(c.world_id, c.commit_id, p_trace, p_manifest) THEN
RAISE EXCEPTION 'cellular birth evidence differs on retry' USING ERRCODE = 'EVL07';
END IF;
RETURN QUERY SELECT * FROM evolution.publish_cellular_checkpoint(
p_manifest, p_decisions, p_actions);
RETURN;
END IF;
-- Lock accounts in stable order and require the exact current control generation
-- and previously allocated request identity before inserting any binding.
FOR birth_row IN SELECT * FROM evolution.cellular_births(p_trace, p_manifest) ORDER BY account_id LOOP
PERFORM evolution.check_life_control(c.world_id, c.region_id, c.holder, c.epoch,
birth_row.account_id, birth_row.generation);
SELECT * INTO r FROM evolution.life_reservations x WHERE x.world_id = c.world_id
AND x.account_id = birth_row.account_id AND x.request_id = birth_row.request_id FOR UPDATE;
IF NOT FOUND OR r.region_id <> c.region_id OR r.identity <> birth_row.identity
OR r.rejection <> 0 OR r.rules <> 1
OR EXISTS (SELECT 1 FROM evolution.primitive_life_bindings x
JOIN evolution.life_reservations y USING (world_id, account_id, request_id)
WHERE x.world_id = c.world_id AND x.account_id = birth_row.account_id
AND y.ended_commit IS NULL) THEN
RAISE EXCEPTION 'cellular birth reservation conflicts' USING ERRCODE = 'EVL16';
END IF;
END LOOP;
FOR birth_row IN SELECT * FROM evolution.cellular_births(p_trace, p_manifest) ORDER BY account_id LOOP
PERFORM evolution.check_life_control(c.world_id, c.region_id, c.holder, c.epoch,
birth_row.account_id, birth_row.generation);
END LOOP;
INSERT INTO evolution.primitive_life_bindings(world_id, account_id, request_id, born, commit_id)
SELECT c.world_id, b.account_id, b.request_id, b.born, c.commit_id
FROM evolution.cellular_births(p_trace, p_manifest) b;
RETURN QUERY SELECT * FROM evolution.publish_cellular_checkpoint(
p_manifest, p_decisions, p_actions);
END $$;
-- The region holding the commit records which of its published lives had ended by then.
-- Identities are u64 little-endian, at most 256 per call. Repeats and identities never
-- reserved (opening founders) are no-ops; a life of
-- another region, unpublished or refused, or an unknown commit is refused.
CREATE FUNCTION evolution.end_cellular_lives(p_world evolution.u64, p_region evolution.u64,
p_holder uuid, p_epoch evolution.u64, p_commit uuid, p_identities bytea)
RETURNS integer LANGUAGE plpgsql SECURITY DEFINER SET search_path = pg_catalog, pg_temp AS $$
DECLARE
n integer;
ended integer := 0;
ending_identity numeric;
r evolution.life_reservations%ROWTYPE;
BEGIN
IF p_commit IS NULL OR p_identities IS NULL OR octet_length(p_identities) % 8 <> 0
OR octet_length(p_identities) / 8 > 256 THEN
RAISE EXCEPTION 'invalid life endings' USING ERRCODE = '22023';
END IF;
PERFORM evolution.check_region_lease(p_world, p_region, p_holder, p_epoch);
IF NOT EXISTS (SELECT 1 FROM evolution.region_commits x WHERE x.world_id = p_world
AND x.region_id = p_region AND x.commit_id = p_commit) THEN
RAISE EXCEPTION 'life ending commit not in region' USING ERRCODE = '22023';
END IF;
n := octet_length(p_identities) / 8;
FOR i IN 0 .. n - 1 LOOP
ending_identity := evolution.manifest_uint(p_identities, 8 * i, 8);
SELECT * INTO r FROM evolution.life_reservations x
WHERE x.world_id = p_world AND x.identity = ending_identity FOR UPDATE;
IF NOT FOUND THEN
CONTINUE; -- An opening founder was never reserved; nothing blocks its account.
END IF;
IF r.region_id <> p_region OR r.rejection <> 0 THEN
RAISE EXCEPTION 'life ending not owned' USING ERRCODE = 'EVL04';
END IF;
IF r.ended_commit IS NULL THEN
UPDATE evolution.life_reservations SET ended_commit = p_commit
WHERE world_id = p_world AND account_id = r.account_id AND request_id = r.request_id;
ended := ended + 1;
END IF;
END LOOP;
RETURN ended;
END $$;
REVOKE ALL ON FUNCTION evolution.life_ending_is_final(),
evolution.end_cellular_lives(evolution.u64, evolution.u64, uuid, evolution.u64, uuid, bytea)
FROM PUBLIC;
GRANT EXECUTE ON FUNCTION
evolution.end_cellular_lives(evolution.u64, evolution.u64, uuid, evolution.u64, uuid, bytea)
TO :"runtime_role";
INSERT INTO evolution.schema_migrations(version, sha256) VALUES (37, :'migration_sha_37');