-- Rules 13 (ADR-0179, Cellular_Revamp_Build_Plan.md): raw-only bundle 15 (rules 13 on owner -- format 11: the cellular revamp) and exact bundle 14 -> 15 upgrades declaring the region's -- revamp rules. Normalization is parser-local; stored evidence and retries retain real bytes. -- Raw trace 4 is unchanged except that a bundle-15 mutation selection may set byte 34 (become). -- The canonical cellular action input: byte 13 bit 1 become (with a bud) and bit 2 emerge (no -- target); byte 14 the matter channels excluded from burning. Widening cannot invalidate an -- existing row; earlier inputs keep both 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) > 7 OR get_byte(p_input, 14) > 15 OR get_byte(p_input, 15) <> 0 OR (get_byte(p_input, 13) & 2 <> 0 AND get_byte(p_input, 12) <> 3) OR (get_byte(p_input, 13) & 4 <> 0 AND get_byte(p_input, 12) <> 0) 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_v59; REVOKE ALL ON FUNCTION evolution.parse_checkpoint_manifest_v59(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; b14 constant bytea := '\x0c0000000a00000002000000010000000100000006000000050000000200000001000000'; b15 constant bytea := '\x0d0000000b00000002000000010000000100000007000000060000000200000001000000'; 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)=b15 THEN c := evolution.parse_checkpoint_manifest_v59(overlay(m PLACING b14 FROM 161 FOR 36)); c.versions := b15; RETURN c; END IF; RETURN evolution.parse_checkpoint_manifest_v59(m); END $$; REVOKE ALL ON FUNCTION evolution.parse_checkpoint_manifest(bytea) FROM PUBLIC; ALTER FUNCTION evolution.cellular_births(bytea,bytea) RENAME TO cellular_births_v59; REVOKE ALL ON FUNCTION evolution.cellular_births_v59(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='\x0d0000000b00000002000000010000000100000007000000060000000200000001000000'::bytea THEN m := overlay(m PLACING '\x0c0000000a00000002000000010000000100000006000000050000000200000001000000'::bytea FROM 161 FOR 36); END IF; RETURN QUERY SELECT * FROM evolution.cellular_births_v59(t,m); END $$; REVOKE ALL ON FUNCTION evolution.cellular_births(bytea,bytea) FROM PUBLIC; -- Results 5 split applied and 6 split refused (rules 13). ALTER TABLE evolution.cellular_mutation_action_publications DROP CONSTRAINT cellular_mutation_action_publications_result_check; ALTER TABLE evolution.cellular_mutation_action_publications ADD CONSTRAINT cellular_mutation_action_publications_result_check CHECK(result BETWEEN 0 AND 6); -- A bundle-15 selection's byte 34 is its become flag (0 or 1). The returned operator carries -- it as bit 15, exactly as the reservation input stores it, so the block check compares them. CREATE OR REPLACE FUNCTION evolution.cellular_mutation_selections(p_trace bytea, p_manifest bytea) RETURNS TABLE(tick evolution.u64, life_id evolution.u64, event_index evolution.u64, offer_tick evolution.u64, successor_identity evolution.u64, operator_id integer) LANGUAGE plpgsql IMMUTABLE SECURITY INVOKER SET search_path = pg_catalog, pg_temp AS $$ DECLARE c evolution.checkpoint_manifest := evolution.parse_checkpoint_manifest(p_manifest); revamp boolean := c.versions = '\x0d0000000b00000002000000010000000100000007000000060000000200000001000000'::bytea; ticks integer; off integer := 112; intent_count integer; birth_count integer; mutation_count integer; previous_life numeric; become integer; BEGIN PERFORM * FROM evolution.cellular_births(p_trace, p_manifest); -- Binding and structure. IF evolution.manifest_uint(p_trace, 8, 4) NOT IN (3,4) THEN RETURN; -- Format 2 carries no selections. END IF; ticks := (c.end_tick - c.begin_tick)::integer; FOR tick_index IN 0 .. ticks - 1 LOOP intent_count := evolution.manifest_uint(p_trace, off, 4)::integer; birth_count := evolution.manifest_uint(p_trace, off + 4, 4)::integer; mutation_count := evolution.manifest_uint(p_trace, off + 8, 4)::integer; off := off + 16 + intent_count * 24 + birth_count * 40; previous_life := 0; FOR mutation_index IN 0 .. mutation_count - 1 LOOP tick := c.begin_tick + tick_index + 1; life_id := evolution.manifest_uint(p_trace, off, 8); event_index := evolution.manifest_uint(p_trace, off + 8, 8); offer_tick := evolution.manifest_uint(p_trace, off + 16, 8); successor_identity := evolution.manifest_uint(p_trace, off + 24, 8); operator_id := evolution.manifest_uint(p_trace, off + 32, 2)::integer; become := get_byte(p_trace, off + 34); IF life_id = 0 OR life_id <= previous_life OR event_index = 0 OR offer_tick = 0 OR offer_tick >= tick OR successor_identity = 0 OR operator_id >= 32768 OR become > (CASE WHEN revamp THEN 1 ELSE 0 END) OR (become = 1 AND operator_id = 0) OR substring(p_trace FROM off + 36 FOR 5) <> '\x0000000000' THEN RAISE EXCEPTION 'invalid cellular mutation selection' USING ERRCODE = '22023'; END IF; operator_id := operator_id + 32768 * become; previous_life := life_id; off := off + 40; RETURN NEXT; END LOOP; END LOOP; END $$; -- Schema 59's block check, with bundle 15's results: a decline is life died or declined; a -- choice is applied (an organism), life died, insufficient funding, split applied or split -- refused. Only bundle 15 stores become (operator bit 15), and only with a choice. 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); b15 constant bytea := '\x0d0000000b00000002000000010000000100000007000000060000000200000001000000'; n integer; account uuid; account_bytes bytea; action numeric; tick numeric; input bytea; stored integer; previous_tick numeric := -1; previous_account bytea := ''::bytea; previous_action numeric := -1; applied numeric; 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); stored := evolution.manifest_uint(input, 32, 2)::integer; 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 = b15 AND ((stored % 32768 = 0 AND (stored >= 32768 OR get_byte(p_results,i) NOT IN (1,3))) OR (stored % 32768 <> 0 AND get_byte(p_results,i) NOT IN (0,1,2,5,6)))) OR (c.versions <> b15 AND stored >= 32768) OR (c.versions IN ('\x0a0000000800000002000000010000000100000004000000030000000200000001000000'::bytea, '\x0b0000000900000002000000010000000100000005000000040000000200000001000000'::bytea, '\x0c0000000a00000002000000010000000100000006000000050000000200000001000000'::bytea) AND (get_byte(p_results,i) NOT IN (1,3,4) OR (stored=0 AND get_byte(p_results,i) NOT IN (1,3)) OR (stored<>0 AND get_byte(p_results,i) NOT IN (1,4)))) OR (c.versions NOT IN ('\x0a0000000800000002000000010000000100000004000000030000000200000001000000'::bytea, '\x0b0000000900000002000000010000000100000005000000040000000200000001000000'::bytea, '\x0c0000000a00000002000000010000000100000006000000050000000200000001000000'::bytea, b15) 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; -- The reservation's tick is the earliest the choice may apply at; the record carries -- the tick it applied at, and the rest of the input must match exactly. applied := tick; IF NOT FOUND OR r.region_id <> c.region_id OR substring(r.input_bytes FROM 9) <> substring(input FROM 9) OR r.target_tick <> evolution.manifest_uint(r.input_bytes, 0, 8) OR applied < r.target_tick 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 = applied 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 = stored) 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_v59; REVOKE ALL ON FUNCTION evolution.publish_cellular_profile_migration_v59(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 := '\x0c0000000a00000002000000010000000100000006000000050000000200000001000000'; target_bundle constant bytea := '\x0d0000000b00000002000000010000000100000007000000060000000200000001000000'; zero32 constant bytea := decode(repeat('00', 32), 'hex'); BEGIN IF c.versions <> target_bundle THEN RETURN QUERY SELECT * FROM evolution.publish_cellular_profile_migration_v59(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 revamp 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 'revamp 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 'revamp 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 revamp 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(60,:'migration_sha_60');