1	import Base
2	import ./change_tick.bend as Tick
3	import column.bend as Col
4	import lifecycle.bend as L
5	import captured_column.bend as K
6	
7	# Closed provisioning supplies affine restoration; universal gameplay sees H.
8	type Cell<-S:Data,-C:Type> is Type:
9	  Taken{id:U32,owner:Maybe<&1,C>,stamp:L.Stamp,dirty:Bool,restore:K.Slot<C> -> Col.Column<S,C>}
10	  Untaken{column:Col.Column<S,C>}
11	type Projected<-S:Data,-C:Type,-V:Data> is Type:
12	  Projected{cell:Cell<S,C>,value:Maybe<&2,V>}
13	  Deferred{cell:Cell<S,C>}
14	
15	def captured(~S:Data,~C:Type,result:K.Capture<S,C>) -> Cell<S,C>:
16	  match result:
17	    case K.Captured{id,owner,stamp,restore}: Taken{id,owner,stamp,False{},restore}
18	    case K.Unavailable{column}: Untaken{column}
19	def detach(~S:Data,~C:Type,column:Col.Column<S,C>,+id:U32) -> Cell<S,C>:
20	  captured(~S,~C,K.capture(~S,~C,column,id))
21	def attach(~S:Data,~C:Type,cell:Cell<S,C>) -> Col.Column<S,C>:
22	  match cell:
23	    case Taken{_,owner,stamp,dirty,restore}: restore(K.Slot{owner,stamp,dirty})
24	    case Untaken{column}: column
25	def projected_owner(~S:Data,~C:Type,~V:Data,+id:U32,stamp:L.Stamp,dirty:Bool,cold:K.Slot<C> -> Col.Column<S,C>,result:C & V) -> Projected<S,C,V>:
26	  match result:
27	    case (owner,value): Projected{Taken{id,Some{owner},stamp,dirty,cold},Some{value}}
28	def project(~S:Data,~C:Type,~V:Data,~project:C -> C & V,cell:Cell<S,C>) -> Projected<S,C,V>:
29	  match cell:
30	    case Taken{id,None{},stamp,dirty,cold}: Projected{Taken{id,None{},stamp,dirty,cold},None{}}
31	    case Taken{id,Some{owner},stamp,dirty,cold}: projected_owner(~S,~C,~V,id,stamp,dirty,cold,project(owner))
32	    case Untaken{column}: Deferred{Untaken{column}}
33	
34	type Replacement<-S:Data,-C:Type> is Type:
35	  Replaced{cell:Cell<S,C>,previous:Maybe<&1,C>,stamp:L.Stamp}
36	  Refused{cell:Cell<S,C>,incoming:C}
37	def replacement_present(~S:Data,~C:Type,+id:U32,+stamp:L.Stamp,cold:K.Slot<C> -> Col.Column<S,C>,incoming:C,+tick:Tick.Tick,observed:Maybe<&1,C> & Bool) -> Replacement<S,C>:
38	  match observed:
39	    case (previous,present): Replaced{Taken{id,Some{incoming},L.after_write(True{},present,stamp,tick),True{},cold},previous,stamp}
40	def owner_present(~C:Type,owner:Maybe<&1,C>) -> Maybe<&1,C> & Bool:
41	  match owner:
42	    case None{}: (None{},False{})
43	    case Some{owner}: (Some{owner},True{})
44	# Caller validates entity/clock first and journals returned previous+stamp now.
45	def replace(~S:Data,~C:Type,cell:Cell<S,C>,incoming:C,+tick:Tick.Tick) -> Replacement<S,C>:
46	  match cell:
47	    case Taken{+id,owner,+stamp,_,cold}: replacement_present(~S,~C,id,stamp,cold,incoming,tick,owner_present(~C,owner))
48	    case Untaken{column}: Refused{Untaken{column},incoming}