FatUnc6969's picture
Publish reviewed Borderland v8 research artifact
2719bf4 verified
Raw History Blame Contribute Delete
13 kB
from __future__ import annotations
from dataclasses import asdict, dataclass, field
from enum import IntEnum
import json
from typing import Any, TYPE_CHECKING
if TYPE_CHECKING:
from .plant import Infrastructure, Charter
class Phase(IntEnum):
RULE_CHAMBER = 1
MOVING_MAZE = 2
ARCHIVE = 3
OSMOSIS = 4
WITNESS_BLOCK = 5
BLACKOUT = 6
FINAL_EXIT = 7
def primitive(value: Any) -> Any:
if isinstance(value, IntEnum):
return int(value)
if hasattr(value, 'to_dict'):
return value.to_dict()
if isinstance(value, dict):
return {str(k): primitive(v) for k, v in value.items()}
if isinstance(value, (tuple, list)):
return [primitive(v) for v in value]
return value
@dataclass(frozen=True)
class Action:
tag: str
arguments: dict = field(default_factory=dict)
def to_dict(self):
return {'tag': self.tag, 'arguments': primitive(self.arguments)}
@dataclass(frozen=True)
class ActionError:
code: str
message: str
def to_dict(self):
return asdict(self)
@dataclass(frozen=True)
class Observation:
phase: Phase
tick: int
charge: int
team: tuple
inventory: tuple
notebook: dict
rules: tuple
board: dict
outcome: str
def to_dict(self):
return {k: primitive(v) for k, v in self.__dict__.items()}
@dataclass(frozen=True)
class Transition:
observation: Observation
legal_actions: tuple[Action, ...]
reward: float = 0.0
terminated: bool = False
truncated: bool = False
outcome: str = 'running'
error: ActionError | None = None
context_reset: bool = False
revision: int = 0
diagnostics: tuple = ()
@property
def done(self):
return self.terminated or self.truncated
def to_dict(self):
return {k: primitive(v) for k, v in self.__dict__.items()}
@dataclass(frozen=True)
class RecordRevision:
id: str
subject: str
statement: str
issued_at: int
supersedes: str | None
seal: str
authenticated: bool
def __getitem__(self, key):
return getattr(self, key)
def to_dict(self):
return asdict(self)
ARCHIVE_WORKLOADS = {'compact': 4, 'standard': 16, 'extended': 64}
ARCHIVE_SUBJECTS = ('restoration', 'authorization', 'egress')
@dataclass(frozen=True)
class ArchiveSpec:
workload: str
pages: tuple
def page(self, slot, page):
return self.pages[slot][page]
def revisions(self):
return tuple(record for scroll in self.pages for page in scroll for record in page)
def revision(self, record_id, issued_at):
return next(record for record in self.revisions() if record.id == record_id and record.issued_at == issued_at)
def current(self, record_id):
return max((record for record in self.revisions() if record.id == record_id and record.authenticated), key=lambda record: record.issued_at)
def authoritative(self):
return tuple(max((record for record in self.revisions() if record.subject == subject and record.authenticated), key=lambda record: record.issued_at) for subject in ARCHIVE_SUBJECTS)
def validate(self):
if self.workload not in ARCHIVE_WORKLOADS or type(self.pages) is not tuple or len(self.pages) != 6:
raise ValueError('Invalid Archive workload or scroll count.')
keys, subjects = set(), {}
for scroll in self.pages:
if type(scroll) is not tuple or len(scroll) != 3:
raise ValueError('Archive scrolls require three pages.')
series = set()
for page in scroll:
if type(page) is not tuple or len(page) != ARCHIVE_WORKLOADS[self.workload]:
raise ValueError('Archive packet size differs from workload.')
for record in page:
if not isinstance(record, RecordRevision) or type(record.issued_at) is not int or record.issued_at < 1 or type(record.id) is not str or not record.id or type(record.subject) is not str or type(record.statement) is not str:
raise ValueError('Invalid revision identity.')
key = record.id, record.issued_at
if key in keys or record.subject not in ARCHIVE_SUBJECTS or subjects.get(record.id, record.subject) != record.subject:
raise ValueError('Duplicate revision or inconsistent subject.')
if record.seal != 'civic' or record.authenticated is not True:
raise ValueError('Revision packets require authenticated civic evidence.')
if record.subject == 'restoration' and sorted(record.statement.split('>')) != ['alpha', 'beta', 'gamma']:
raise ValueError('Invalid restoration statement.')
if record.subject == 'authorization' and record.statement not in {w+'/'+s for w in ('Iris','Juno','Kade') for s in ('amber','cobalt','silver')}:
raise ValueError('Invalid authorization statement.')
if record.subject == 'egress' and record.statement not in ('0','1','2'):
raise ValueError('Invalid egress statement.')
keys.add(key); series.add(record.id); subjects[record.id] = record.subject
if len(series) != 1:
raise ValueError('Each scroll must contain one stable series.')
if len(subjects) != 6 or any(list(subjects.values()).count(subject) != 2 for subject in ARCHIVE_SUBJECTS):
raise ValueError('Archive requires two series for each subject.')
for record in self.revisions():
if record.supersedes is not None and (record.supersedes == record.id or subjects.get(record.supersedes) != record.subject):
raise ValueError('Invalid predecessor series.')
for current in self.authoritative():
peers = [self.current(rid) for rid, subject in subjects.items() if subject == current.subject]
if peers[0].issued_at == peers[1].issued_at or current.supersedes is None:
raise ValueError('Ambiguous endpoint or missing endpoint predecessor.')
predecessor = self.current(current.supersedes)
if predecessor.supersedes is not None or predecessor.issued_at >= current.issued_at:
raise ValueError('Invalid endpoint chain.')
@dataclass(frozen=True)
class WorldSpec:
generation_version: int
ruleset: str
private_seed: int
polarity: int
doctrine: str
maze_rotation: int
archive: ArchiveSpec | Charter
restoration_order: tuple
current_witness: str
current_seal: str
correct_track: int
initial_charge: int
reference_cost: int
infrastructure: Infrastructure | None = None
notebook_bytes: int = 768
memory_profile: str = 'static'
def __post_init__(self):
if self.memory_profile not in ('static', 'commissioning') or (self.memory_profile == 'commissioning' and self.generation_version != 3):
raise ValueError('Unsupported memory profile or generation.')
if self.generation_version == 3:
from .plant import Infrastructure, Charter, circuit_order, permit_decision, exit_decision, BUDGETS
p = self.infrastructure
if not isinstance(p, Infrastructure) or not isinstance(self.archive, Charter) or self.ruleset != 'campaign':
raise ValueError('Generation three requires typed campaign infrastructure and charter.')
p.validate(); self.archive.validate()
if (p.load_schedule is not None) != (self.memory_profile == 'commissioning'):
raise ValueError('Memory profile must match the infrastructure load schedule.')
if sorted(self.archive.revisions(), key=lambda r: r.id) != sorted(p.revisions, key=lambda r: r.id):
raise ValueError('Archive evidence contradicts infrastructure.')
witness, seal = permit_decision(p)
if (self.polarity, self.maze_rotation, self.restoration_order, self.current_witness, self.current_seal, self.correct_track, self.doctrine) != (p.calibrations[0].sensor_xor, p.calibrations[0].phase_offset, circuit_order(p), witness, seal, exit_decision(p)[0], p.opponent.kind):
raise ValueError('Legacy compatibility values must be derived from infrastructure.')
if self.initial_charge != BUDGETS[self.archive.workload]:
raise ValueError('Generation three uses a profile-fixed initial charge budget.')
if type(self.notebook_bytes) is not int or self.notebook_bytes < 0:
raise ValueError('Notebook bytes must be a nonnegative integer.')
return
if self.generation_version != 2 or self.infrastructure is not None:
raise ValueError('Unsupported generation. Use the pinned source for historical worlds.')
self.archive.validate()
statements = {record.subject: record.statement for record in self.archive.authoritative()}
if statements != dict(restoration='>'.join(self.restoration_order), authorization=self.current_witness+'/'+self.current_seal, egress=str(self.correct_track)):
raise ValueError('Archive endpoints contradict causal world facts.')
@property
def correct_records(self):
if self.generation_version == 3:
return tuple(self.infrastructure.current(service).id for service in self.infrastructure.services)
return tuple(record.id for record in self.archive.authoritative())
@dataclass
class RuleState:
kind: str = 'rule_chamber'
latch: int = 0
fixture: str | None = None
live_sensor: int | None = None
gate_open: bool = False
sensor_visible: bool = False
pulse_count: int = 0
experiments: list = field(default_factory=list)
channel: str | None = None
phase_mark: int | None = None
@dataclass
class MazeState:
kind: str = 'moving_maze'
cell: int = 0
clock: int = 0
rotor_offset: int = 0
scanned: bool = False
collected: list = field(default_factory=list)
discovered: list = field(default_factory=list)
@dataclass
class ArchiveState:
kind: str = 'archive'
slot: int | None = None
page: int = 0
exposed_versions: dict = field(default_factory=dict)
compared_versions: set = field(default_factory=set)
result: str | None = None
filed: dict = field(default_factory=dict)
@dataclass
class OsmosisState:
kind: str = 'osmosis'
turn: int = 0
allies: list = field(default_factory=lambda: [dict(actor=a, node='home', power=p, exhaustion=0, flag=False, support=0) for a, p in [('Ada', 5), ('Bo', 4), ('Cy', 3)]])
enemies: list = field(default_factory=lambda: [dict(actor='guard', node='east', power=5, exhaustion=0, flag=False), dict(actor='keeper', node='enemy', power=3, exhaustion=0, flag=True)])
allied_points: int = 0
enemy_points: int = 0
west_commitments: int = 0
east_commitments: int = 0
raid_telegraph: bool = False
reaction: str = 'No opponent move yet.'
bridge_available: bool = False
contest_over: bool = False
relay_claimed: bool = False
relay_cooldown: int = 0
base_captured: bool = False
orders: list = field(default_factory=list)
loaded_crossings: int = 0
@dataclass
class WitnessState:
kind: str = 'witness_block'
player_cell: int = 0
witness_cells: dict = field(default_factory=lambda: {'Iris': 1, 'Juno': 2, 'Kade': 3})
claim: dict | None = None
checks: list = field(default_factory=list)
checkpoint_test: str | None = None
closure_in: int = 12
clock: int = 0
@dataclass
class BlackoutState:
kind: str = 'blackout'
circuits: list = field(default_factory=lambda: [dict(id=x, bus=None, status='isolated') for x in ['alpha', 'beta', 'gamma']])
activation_order: list = field(default_factory=list)
discount_used: bool = False
@dataclass
class ExitState:
kind: str = 'final_exit'
installed: dict = field(default_factory=dict)
track: int = 0
boarded: list = field(default_factory=list)
armed_with: str | None = None
valve: str | None = None
pressure_vented: bool = False
RoomState = RuleState | MazeState | ArchiveState | OsmosisState | WitnessState | BlackoutState | ExitState
@dataclass
class CampaignState:
phase: Phase
tick: int
charge: int
room: RoomState
team: list = field(default_factory=lambda: [dict(id=a, power=p, exhaustion=0, available=True) for a, p in [('Ada', 5), ('Bo', 4), ('Cy', 3)]])
inventory: list = field(default_factory=list)
notebook: str = ''
witness_authorization: str | None = None
docket: dict = field(default_factory=dict)
outcome: str = 'running'
revision: int = 0
feedback: Any = None
def canonical(value):
return json.dumps(primitive(value), sort_keys=True, separators=(',', ':'), ensure_ascii=False, allow_nan=False)