1	import Base
2	import ./change_tick.bend as Tick
3	import ./restore_public.bend as Public
4	import ./restore_schema.bend as Schema
5	import ./restore_data.bend as R
6	import ./restore_prepare.bend as Prepare
7	import ./restore_apply.bend as Apply
8	import ./restore_world.bend as Adapter
9	import ./snapshot_data.bend as Snapshot
10	import ./decode_data.bend as D
11	import ./world.bend as W
12	import ./event_family_routing.bend as Route
13	import ./event_family_runtime.bend as Family
14	import ./ordinary_owned_event_family_reader.bend as Reader
15	import ./owned_event_family_maintenance.bend as Maintenance
16	import ./owned_event_family_catalog.bend as Catalog
17	import ./owner_product.bend as Product
18	
19	def packed(~S:Data,~C:Type,~User:Type,~Logs:Type,~E:Data,~F:Type,~EventOwners:Type,~Receipt:Type,~State:Type,~Custom:Data,~stage:State -> R.Position -> D.Field -> State & R.Dispatch<Custom>,~release:State -> State,~clear:C -> W.Handle<S> -> C & List<&2,R.Change<S>>,~insert:C -> Product.Owner<User,Logs> -> State -> List<&2,R.Binding<S>> -> Tick.Tick -> (C & Product.Owner<User,Logs>) & State,~emit:R.Change<S> -> E,~retain:Logs -> List<&2,E> -> Logs & Receipt,~drain:Logs -> Logs & Receipt,~clearStreams:F -> F,~catalog:Catalog.Catalog<E,Logs,F,Receipt,retain,drain,clearStreams>,~sync:F -> Nat -> List<&2,E> -> F,~Recovery:Type,~commit:State -> State,~takeRecovery:State -> State & Recovery,synchronize:Bool,family:Family.State<E,F,EventOwners>,tick:Nat,receipt:Maybe<&1,Receipt>,observed:W.World<S,C,Product.Owner<User,Logs>,E> & (Public.Owner<S,C,Product.Owner<User,Logs>,State,Custom,stage,release,clear,insert,Recovery,commit,takeRecovery> & (Public.Outcome<S,Custom> & Recovery))) -> Route.Runtime<S,C,Product.Owner<User,Logs>,E,Family.State<E,F,EventOwners>> & (Public.Owner<S,C,Product.Owner<User,Logs>,State,Custom,stage,release,clear,insert,Recovery,commit,takeRecovery> & (Public.Outcome<S,Custom> & (Recovery & Maybe<&1,Receipt>))):
20	  match synchronize observed:
21	    case False{},(world,(owner,(outcome,recovery))):(Route.Runtime{world,family,tick},(owner,(outcome,(recovery,receipt))))
22	    case True{},(world,(owner,(outcome,recovery))):Reader.world_returned(~S,~C,~Product.Owner<User,Logs>,~E,~F,~EventOwners,~sync,~(Public.Owner<S,C,Product.Owner<User,Logs>,State,Custom,stage,release,clear,insert,Recovery,commit,takeRecovery> & (Public.Outcome<S,Custom> & (Recovery & Maybe<&1,Receipt>))),family,1n+tick,(world,(owner,(outcome,(recovery,receipt)))))
23	def finished(~S:Data,~C:Type,~User:Type,~Logs:Type,~E:Data,~F:Type,~EventOwners:Type,~Receipt:Type,~State:Type,~Custom:Data,~stage:State -> R.Position -> D.Field -> State & R.Dispatch<Custom>,~release:State -> State,~clear:C -> W.Handle<S> -> C & List<&2,R.Change<S>>,~insert:C -> Product.Owner<User,Logs> -> State -> List<&2,R.Binding<S>> -> Tick.Tick -> (C & Product.Owner<User,Logs>) & State,~emit:R.Change<S> -> E,~retain:Logs -> List<&2,E> -> Logs & Receipt,~drain:Logs -> Logs & Receipt,~clearStreams:F -> F,~catalog:Catalog.Catalog<E,Logs,F,Receipt,retain,drain,clearStreams>,~sync:F -> Nat -> List<&2,E> -> F,~Recovery:Type,~commit:State -> State,~takeRecovery:State -> State & Recovery,schema:Schema.Schema<S,C,Product.Owner<User,Logs>,State,Custom,stage,release,clear,insert,Recovery,commit,takeRecovery>,family:Family.State<E,F,EventOwners>,tick:Nat,receipt:Receipt,result:Apply.ApplyResult<S,C,Product.Owner<User,Logs>,E,State,Custom>) -> Route.Runtime<S,C,Product.Owner<User,Logs>,E,Family.State<E,F,EventOwners>> & (Public.Owner<S,C,Product.Owner<User,Logs>,State,Custom,stage,release,clear,insert,Recovery,commit,takeRecovery> & (Public.Outcome<S,Custom> & (Recovery & Maybe<&1,Receipt>))):
24	  match result:
25	    case Apply.Applied{world,state,bindings}:packed(~S,~C,~User,~Logs,~E,~F,~EventOwners,~Receipt,~State,~Custom,~stage,~release,~clear,~insert,~emit,~retain,~drain,~clearStreams,~catalog,~sync,~Recovery,~commit,~takeRecovery,True{},family,tick,Some{receipt},Public.run_returned(~S,~C,~Product.Owner<User,Logs>,~E,~State,~Custom,~stage,~release,~clear,~insert,~Recovery,~commit,~takeRecovery,schema,Apply.Applied{world,state,bindings}))
26	    case Apply.Refused{world,state,input,error}:packed(~S,~C,~User,~Logs,~E,~F,~EventOwners,~Receipt,~State,~Custom,~stage,~release,~clear,~insert,~emit,~retain,~drain,~clearStreams,~catalog,~sync,~Recovery,~commit,~takeRecovery,False{},family,tick,Some{receipt},Public.run_returned(~S,~C,~Product.Owner<User,Logs>,~E,~State,~Custom,~stage,~release,~clear,~insert,~Recovery,~commit,~takeRecovery,schema,Apply.Refused{world,state,input,error}))
27	def drained(~S:Data,~C:Type,~User:Type,~Logs:Type,~E:Data,~F:Type,~EventOwners:Type,~Receipt:Type,~State:Type,~Custom:Data,~stage:State -> R.Position -> D.Field -> State & R.Dispatch<Custom>,~release:State -> State,~clear:C -> W.Handle<S> -> C & List<&2,R.Change<S>>,~insert:C -> Product.Owner<User,Logs> -> State -> List<&2,R.Binding<S>> -> Tick.Tick -> (C & Product.Owner<User,Logs>) & State,~emit:R.Change<S> -> E,~retain:Logs -> List<&2,E> -> Logs & Receipt,~drain:Logs -> Logs & Receipt,~clearStreams:F -> F,~catalog:Catalog.Catalog<E,Logs,F,Receipt,retain,drain,clearStreams>,~sync:F -> Nat -> List<&2,E> -> F,~Recovery:Type,~commit:State -> State,~takeRecovery:State -> State & Recovery,schema:Schema.Schema<S,C,Product.Owner<User,Logs>,State,Custom,stage,release,clear,insert,Recovery,commit,takeRecovery>,prepared:R.Prepared<State,Custom>,observed:Route.Runtime<S,C,Product.Owner<User,Logs>,E,Family.State<E,F,EventOwners>> & Receipt) -> Route.Runtime<S,C,Product.Owner<User,Logs>,E,Family.State<E,F,EventOwners>> & (Public.Owner<S,C,Product.Owner<User,Logs>,State,Custom,stage,release,clear,insert,Recovery,commit,takeRecovery> & (Public.Outcome<S,Custom> & (Recovery & Maybe<&1,Receipt>))):
28	  match observed:
29	    case (Route.Runtime{world,family,tick},receipt):finished(~S,~C,~User,~Logs,~E,~F,~EventOwners,~Receipt,~State,~Custom,~stage,~release,~clear,~insert,~emit,~retain,~drain,~clearStreams,~catalog,~sync,~Recovery,~commit,~takeRecovery,schema,family,tick,receipt,Apply.apply(~S,~C,~Product.Owner<User,Logs>,~E,~State,~Custom,~release,~clear,~insert,~emit,world,prepared))
30	def roomed(~S:Data,~C:Type,~User:Type,~Logs:Type,~E:Data,~F:Type,~EventOwners:Type,~Receipt:Type,~State:Type,~Custom:Data,~stage:State -> R.Position -> D.Field -> State & R.Dispatch<Custom>,~release:State -> State,~clear:C -> W.Handle<S> -> C & List<&2,R.Change<S>>,~insert:C -> Product.Owner<User,Logs> -> State -> List<&2,R.Binding<S>> -> Tick.Tick -> (C & Product.Owner<User,Logs>) & State,~emit:R.Change<S> -> E,~retain:Logs -> List<&2,E> -> Logs & Receipt,~drain:Logs -> Logs & Receipt,~clearStreams:F -> F,~catalog:Catalog.Catalog<E,Logs,F,Receipt,retain,drain,clearStreams>,~sync:F -> Nat -> List<&2,E> -> F,~Recovery:Type,~commit:State -> State,~takeRecovery:State -> State & Recovery,schema:Schema.Schema<S,C,Product.Owner<User,Logs>,State,Custom,stage,release,clear,insert,Recovery,commit,takeRecovery>,state:State,+input:Snapshot.Snapshot,family:Family.State<E,F,EventOwners>,tick:Nat,+floor:U32,observed:W.World<S,C,Product.Owner<User,Logs>,E> & Bool) -> Route.Runtime<S,C,Product.Owner<User,Logs>,E,Family.State<E,F,EventOwners>> & (Public.Owner<S,C,Product.Owner<User,Logs>,State,Custom,stage,release,clear,insert,Recovery,commit,takeRecovery> & (Public.Outcome<S,Custom> & (Recovery & Maybe<&1,Receipt>))):
31	  match observed:
32	    case (world,False{}):packed(~S,~C,~User,~Logs,~E,~F,~EventOwners,~Receipt,~State,~Custom,~stage,~release,~clear,~insert,~emit,~retain,~drain,~clearStreams,~catalog,~sync,~Recovery,~commit,~takeRecovery,False{},family,tick,None{},Public.run_returned(~S,~C,~Product.Owner<User,Logs>,~E,~State,~Custom,~stage,~release,~clear,~insert,~Recovery,~commit,~takeRecovery,schema,Apply.Refused{world,state,input,R.Capacity{floor}}))
33	    case (world,True{}):drained(~S,~C,~User,~Logs,~E,~F,~EventOwners,~Receipt,~State,~Custom,~stage,~release,~clear,~insert,~emit,~retain,~drain,~clearStreams,~catalog,~sync,~Recovery,~commit,~takeRecovery,schema,R.BendvyReady{state,input},Maintenance.shutdown(~S,~C,~User,~Logs,~E,~F,~EventOwners,~Receipt,~retain,~drain,~clearStreams,~catalog,Route.Runtime{world,family,tick}))
34	def prepared(~S:Data,~C:Type,~User:Type,~Logs:Type,~E:Data,~F:Type,~EventOwners:Type,~Receipt:Type,~State:Type,~Custom:Data,~stage:State -> R.Position -> D.Field -> State & R.Dispatch<Custom>,~release:State -> State,~clear:C -> W.Handle<S> -> C & List<&2,R.Change<S>>,~insert:C -> Product.Owner<User,Logs> -> State -> List<&2,R.Binding<S>> -> Tick.Tick -> (C & Product.Owner<User,Logs>) & State,~emit:R.Change<S> -> E,~retain:Logs -> List<&2,E> -> Logs & Receipt,~drain:Logs -> Logs & Receipt,~clearStreams:F -> F,~catalog:Catalog.Catalog<E,Logs,F,Receipt,retain,drain,clearStreams>,~sync:F -> Nat -> List<&2,E> -> F,~Recovery:Type,~commit:State -> State,~takeRecovery:State -> State & Recovery,schema:Schema.Schema<S,C,Product.Owner<User,Logs>,State,Custom,stage,release,clear,insert,Recovery,commit,takeRecovery>,runtime:Route.Runtime<S,C,Product.Owner<User,Logs>,E,Family.State<E,F,EventOwners>>,result:R.Prepared<State,Custom>) -> Route.Runtime<S,C,Product.Owner<User,Logs>,E,Family.State<E,F,EventOwners>> & (Public.Owner<S,C,Product.Owner<User,Logs>,State,Custom,stage,release,clear,insert,Recovery,commit,takeRecovery> & (Public.Outcome<S,Custom> & (Recovery & Maybe<&1,Receipt>))):
35	  match runtime result:
36	    case Route.Runtime{world,family,tick} R.Refused{state,input,error}:packed(~S,~C,~User,~Logs,~E,~F,~EventOwners,~Receipt,~State,~Custom,~stage,~release,~clear,~insert,~emit,~retain,~drain,~clearStreams,~catalog,~sync,~Recovery,~commit,~takeRecovery,False{},family,tick,None{},Public.run_returned(~S,~C,~Product.Owner<User,Logs>,~E,~State,~Custom,~stage,~release,~clear,~insert,~Recovery,~commit,~takeRecovery,schema,Apply.Refused{world,state,input,error}))
37	    case Route.Runtime{world,family,tick} R.BendvyReady{state,Snapshot.Snapshot{+version,+floor,+entities,+resources}}:roomed(~S,~C,~User,~Logs,~E,~F,~EventOwners,~Receipt,~State,~Custom,~stage,~release,~clear,~insert,~emit,~retain,~drain,~clearStreams,~catalog,~sync,~Recovery,~commit,~takeRecovery,schema,state,Snapshot.Snapshot{version,floor,entities,resources},family,tick,floor,Adapter.room(~S,~C,~Product.Owner<User,Logs>,~E,world,floor,Apply.count_entities(entities)))
38	# Restore typed snapshot through the retained schema Owner and actual family
39	# runtime. Complete preparation and capacity admission precede log drain/World
40	# cleanup. Early refusal retains runtime and returns no drain receipt; owned
41	# constructor recovery and rejected input remain explicit in Public.Outcome.
42	# After admission, drain actual affine logs via the complete typed catalog and
43	# clear stream/publication state, then apply canonical cleanup/fresh spawning and
44	# saved-key-to-handle bindings. Pending closures are dropped without execution and
45	# Pending allocator marks abandoned; saved keys are not restored live identities.
46	# Return actual restore Owner, constructor recovery and optional drain Receipt with
47	# runtime. Success synchronizes restored publications at the next family tick;
48	# this is not a full runtime reset: registration/Local/capture/reader owners remain
49	# subject to the existing retained-runtime contract. No payload is copied into a
50	# detached recovery value or silently disposed by a fabricated host destructor.
51	# See docs/parity/restore-basic.md for the complete runtime omissions/boundary.
52	def run(~S:Data,~C:Type,~User:Type,~Logs:Type,~E:Data,~F:Type,~EventOwners:Type,~Receipt:Type,~State:Type,~Custom:Data,~stage:State -> R.Position -> D.Field -> State & R.Dispatch<Custom>,~release:State -> State,~clear:C -> W.Handle<S> -> C & List<&2,R.Change<S>>,~insert:C -> Product.Owner<User,Logs> -> State -> List<&2,R.Binding<S>> -> Tick.Tick -> (C & Product.Owner<User,Logs>) & State,~emit:R.Change<S> -> E,~retain:Logs -> List<&2,E> -> Logs & Receipt,~drain:Logs -> Logs & Receipt,~clearStreams:F -> F,~catalog:Catalog.Catalog<E,Logs,F,Receipt,retain,drain,clearStreams>,~sync:F -> Nat -> List<&2,E> -> F,~Recovery:Type,~commit:State -> State,~takeRecovery:State -> State & Recovery,owner:Public.Owner<S,C,Product.Owner<User,Logs>,State,Custom,stage,release,clear,insert,Recovery,commit,takeRecovery>,runtime:Route.Runtime<S,C,Product.Owner<User,Logs>,E,Family.State<E,F,EventOwners>>,input:Snapshot.Snapshot) -> Route.Runtime<S,C,Product.Owner<User,Logs>,E,Family.State<E,F,EventOwners>> & (Public.Owner<S,C,Product.Owner<User,Logs>,State,Custom,stage,release,clear,insert,Recovery,commit,takeRecovery> & (Public.Outcome<S,Custom> & (Recovery & Maybe<&1,Receipt>))):
53	  match owner:
54	    case Public.Owner{schema,state}:prepared(~S,~C,~User,~Logs,~E,~F,~EventOwners,~Receipt,~State,~Custom,~stage,~release,~clear,~insert,~emit,~retain,~drain,~clearStreams,~catalog,~sync,~Recovery,~commit,~takeRecovery,schema,runtime,Prepare.prepare(~State,~Custom,~stage,~release,state,input))