1	import Base
2	import ./world.bend as W
3	import ./ordinary_app_schema.bend as SchemaApp
4	import ./ordinary_app_schedule.bend as Schedule
5	import ./ordinary_app_schedule_description.bend as Named
6	import ./ordinary_app_observation_data.bend as DTO
7	import ./ordinary_app_registration_fields.bend as Fields
8	import ./ordinary_condition_declaration.bend as Condition
9	import ./schedule.bend as Sch
10	import ./schedule_provision.bend as SP
11	import ./system.bend as Sys
12	# The same closed ordinary Program derives operational routing and descriptions.
13	# Existing provision, step order, dispatch, condition truth, skip and barriers run
14	# unchanged. Stateful registered conditions/readers remain outside this adapter.
15	# Ordinary scheduled App retaining materialized condition entries from the
16	# same closed Program used to route predicates. World/system owners remain
17	# single; stateful registered guards/readers use their separate binding APIs.
18	type Application<S:Data,C:Type,R:Type,E:Data,H:Type,Rows:Data,-observe:W.World<S,C,R,E> -> W.World<S,C,R,E> & DTO.Observation<Rows>,-fold:H -> H & List<&2,Fields.Fields<S>>,-Ids:Data,-declaration:Condition.Program<S,C,R,E,Ids>> is Type:
19	  Application{scheduled:Schedule.Application<S,C,R,E,H,Rows,observe,fold>,program:Condition.Entries<S>}
20	# Detached condition name/slot at an actual system position.
21	# Missing name remains None rather than creating a new condition declaration.
22	type ConditionPlacement is Data:
23	  ConditionPlacement{position:Nat,slot:U32,name:Maybe<&2,String>}
24	# Detached enabled-debug schedule view with its condition placements.
25	# Contains no guard owners, World save or additional gameplay authority.
26	type Description<S:Data,Rows:Data> is Data:
27	  Description{schedule:Named.Description<S,Rows>,conditions:List<&2,ConditionPlacement>}
28	def attached(~S:Data,~C:Type,~R:Type,~E:Data,~H:Type,~Rows:Data,~observe:W.World<S,C,R,E> -> W.World<S,C,R,E> & DTO.Observation<Rows>,~fold:H -> H & List<&2,Fields.Fields<S>>,~Ids:Data,~declaration:Condition.Program<S,C,R,E,Ids>,program:Condition.Entries<S>,result:Schedule.Attachment<SchemaApp.Application<S,C,R,E,H,Rows,observe,fold>,Schedule.Application<S,C,R,E,H,Rows,observe,fold>>) -> Schedule.Attachment<SchemaApp.Application<S,C,R,E,H,Rows,observe,fold>,Application<S,C,R,E,H,Rows,observe,fold,Ids,declaration>>:
29	  match result:
30	    case Schedule.Attached{scheduled}:Schedule.Attached{Application{scheduled,program}}
31	    case Schedule.Invalid{app}:Schedule.Invalid{app}
32	def validated(~S:Data,~C:Type,~R:Type,~E:Data,~H:Type,~Rows:Data,~observe:W.World<S,C,R,E> -> W.World<S,C,R,E> & DTO.Observation<Rows>,~fold:H -> H & List<&2,Fields.Fields<S>>,~Ids:Data,~declaration:Condition.Program<S,C,R,E,Ids>,valid:Bool,app:SchemaApp.Application<S,C,R,E,H,Rows,observe,fold>,name:String,+program:Condition.Entries<S>) -> Schedule.Attachment<SchemaApp.Application<S,C,R,E,H,Rows,observe,fold>,Application<S,C,R,E,H,Rows,observe,fold,Ids,declaration>>:
33	  match valid:
34	    case False{}:Schedule.Invalid{app}
35	    case True{}:attached(~S,~C,~R,~E,~H,~Rows,~observe,~fold,~Ids,~declaration,program,Schedule.attach(~S,~C,~R,~E,~H,~Rows,~observe,~fold,app,name,Condition.plan(~S,program)))
36	def prepared(~S:Data,~C:Type,~R:Type,~E:Data,~H:Type,~Rows:Data,~observe:W.World<S,C,R,E> -> W.World<S,C,R,E> & DTO.Observation<Rows>,~fold:H -> H & List<&2,Fields.Fields<S>>,~Ids:Data,~declaration:Condition.Program<S,C,R,E,Ids>,app:SchemaApp.Application<S,C,R,E,H,Rows,observe,fold>,name:String,+program:Condition.Entries<S>) -> Schedule.Attachment<SchemaApp.Application<S,C,R,E,H,Rows,observe,fold>,Application<S,C,R,E,H,Rows,observe,fold,Ids,declaration>>:
37	  validated(~S,~C,~R,~E,~H,~Rows,~observe,~fold,~Ids,~declaration,Condition.valid(~S,program),app,name,program)
38	# Materialize/structurally validate the closed condition Program, then
39	# validate ordinary schedule attachment against existing registrations.
40	# Invalid returns the original App owner; Attached retains App and entries.
41	# No guard/system body or structural barrier executes while attaching.
42	def attach(~S:Data,~C:Type,~R:Type,~E:Data,~H:Type,~Rows:Data,~observe:W.World<S,C,R,E> -> W.World<S,C,R,E> & DTO.Observation<Rows>,~fold:H -> H & List<&2,Fields.Fields<S>>,~Ids:Data,~declaration:Condition.Program<S,C,R,E,Ids>,app:SchemaApp.Application<S,C,R,E,H,Rows,observe,fold>,name:String,ids:Ids) -> Schedule.Attachment<SchemaApp.Application<S,C,R,E,H,Rows,observe,fold>,Application<S,C,R,E,H,Rows,observe,fold,Ids,declaration>>:
43	  prepared(~S,~C,~R,~E,~H,~Rows,~observe,~fold,~Ids,~declaration,app,name,Condition.materialize(~S,~C,~R,~E,~Ids,declaration,ids))
44	# Toggle debug, retaining App and materialized condition entries.
45	# Does not evaluate guards or registered systems.
46	def enabled(~S:Data,~C:Type,~R:Type,~E:Data,~H:Type,~Rows:Data,~observe:W.World<S,C,R,E> -> W.World<S,C,R,E> & DTO.Observation<Rows>,~fold:H -> H & List<&2,Fields.Fields<S>>,~Ids:Data,~declaration:Condition.Program<S,C,R,E,Ids>,app:Application<S,C,R,E,H,Rows,observe,fold,Ids,declaration>,flag:Bool) -> Application<S,C,R,E,H,Rows,observe,fold,Ids,declaration>:
47	  match app:
48	    case Application{scheduled,program}:Application{Schedule.enabled(~S,~C,~R,~E,~H,~Rows,~observe,~fold,scheduled,flag),program}
49	def condition_placement(~S:Data,~C:Type,~R:Type,~E:Data,~H:Type,~Rows:Data,~observe:W.World<S,C,R,E> -> W.World<S,C,R,E> & DTO.Observation<Rows>,~fold:H -> H & List<&2,Fields.Fields<S>>,~Ids:Data,~declaration:Condition.Program<S,C,R,E,Ids>,+program:Condition.Entries<S>,placement:Named.Placement<S>) -> Maybe<&2,ConditionPlacement>:
50	  match placement:
51	    case Named.System{position,_,_,_,+slot,_}:Some{ConditionPlacement{position,slot,Condition.condition_name(~S,program,slot)}}
52	    case Named.Phase{_,_,_}:None{}
53	    case Named.Barrier{_,_}:None{}
54	def added(first:Maybe<&2,ConditionPlacement>,rest:List<&2,ConditionPlacement>) -> List<&2,ConditionPlacement>:
55	  match first:
56	    case None{}:rest
57	    case Some{view}:view <> rest
58	def placements(~S:Data,~C:Type,~R:Type,~E:Data,~H:Type,~Rows:Data,~observe:W.World<S,C,R,E> -> W.World<S,C,R,E> & DTO.Observation<Rows>,~fold:H -> H & List<&2,Fields.Fields<S>>,~Ids:Data,~declaration:Condition.Program<S,C,R,E,Ids>,items:List<&2,Named.Placement<S>>,+program:Condition.Entries<S>) -> List<&2,ConditionPlacement>:
59	  match items:
60	    case []:[]
61	    case first <> rest:added(condition_placement(~S,~C,~R,~E,~H,~Rows,~observe,~fold,~Ids,~declaration,program,first),placements(~S,~C,~R,~E,~H,~Rows,~observe,~fold,~Ids,~declaration,rest,program))
62	def described(~S:Data,~C:Type,~R:Type,~E:Data,~H:Type,~Rows:Data,~observe:W.World<S,C,R,E> -> W.World<S,C,R,E> & DTO.Observation<Rows>,~fold:H -> H & List<&2,Fields.Fields<S>>,~Ids:Data,~declaration:Condition.Program<S,C,R,E,Ids>,+program:Condition.Entries<S>,description:Named.Description<S,Rows>) -> Description<S,Rows>:
63	  match description:
64	    case Named.Description{original,+items}:Description{Named.Description{original,items},placements(~S,~C,~R,~E,~H,~Rows,~observe,~fold,~Ids,~declaration,items,program)}
65	def observed(~S:Data,~C:Type,~R:Type,~E:Data,~H:Type,~Rows:Data,~observe:W.World<S,C,R,E> -> W.World<S,C,R,E> & DTO.Observation<Rows>,~fold:H -> H & List<&2,Fields.Fields<S>>,~Ids:Data,~declaration:Condition.Program<S,C,R,E,Ids>,+program:Condition.Entries<S>,result:Schedule.Application<S,C,R,E,H,Rows,observe,fold> & Maybe<&2,Named.Description<S,Rows>>) -> Application<S,C,R,E,H,Rows,observe,fold,Ids,declaration> & Maybe<&2,Description<S,Rows>>:
66	  match result:
67	    case (scheduled,None{}):(Application{scheduled,program},None{})
68	    case (scheduled,Some{view}):(Application{scheduled,program},Some{described(~S,~C,~R,~E,~H,~Rows,~observe,~fold,~Ids,~declaration,program,view)})
69	# Return App with optional detached schedule/condition descriptions.
70	# Disabled observation returns None; enabled names come from the same ordinary
71	# program. Does not evaluate predicates or advance system reader cursors.
72	def snapshot(~S:Data,~C:Type,~R:Type,~E:Data,~H:Type,~Rows:Data,~observe:W.World<S,C,R,E> -> W.World<S,C,R,E> & DTO.Observation<Rows>,~fold:H -> H & List<&2,Fields.Fields<S>>,~Ids:Data,~declaration:Condition.Program<S,C,R,E,Ids>,app:Application<S,C,R,E,H,Rows,observe,fold,Ids,declaration>) -> Application<S,C,R,E,H,Rows,observe,fold,Ids,declaration> & Maybe<&2,Description<S,Rows>>:
73	  match app:
74	    case Application{scheduled,program}:observed(~S,~C,~R,~E,~H,~Rows,~observe,~fold,~Ids,~declaration,program,Named.snapshot(~S,~C,~R,~E,~H,~Rows,~observe,~fold,scheduled))
75	def executed(~S:Data,~C:Type,~R:Type,~E:Data,~H:Type,~Rows:Data,~observe:W.World<S,C,R,E> -> W.World<S,C,R,E> & DTO.Observation<Rows>,~fold:H -> H & List<&2,Fields.Fields<S>>,~Ids:Data,~declaration:Condition.Program<S,C,R,E,Ids>,~Error:Data,program:Condition.Entries<S>,result:Schedule.RunResult<Schedule.Application<S,C,R,E,H,Rows,observe,fold>,S,Error>) -> Schedule.RunResult<Application<S,C,R,E,H,Rows,observe,fold,Ids,declaration>,S,Error>:
76	  match result:
77	    case Schedule.Finished{scheduled,observations}:Schedule.Finished{Application{scheduled,program},observations}
78	    case Schedule.Failed{scheduled,error,observations}:Schedule.Failed{Application{scheduled,program},error,observations}
79	    case Schedule.Rejected{scheduled}:Schedule.Rejected{Application{scheduled,program}}
80	    case Schedule.Missing{scheduled,requirements}:Schedule.Missing{Application{scheduled,program},requirements}
81	# Run the retained ordinary schedule with the matching Program evaluator.
82	# False skips dispatch; ordinary condition World changes are retained even
83	# when false because predicates are trusted World-threading callbacks.
84	# Provision/admission failures retain App; system failure preserves earlier
85	# successful steps and the failed runner's transaction contract. Structural
86	# visibility changes only at explicit barriers, not automatically at run end.
87	def run(~S:Data,~C:Type,~R:Type,~E:Data,~H:Type,~Rows:Data,~observe:W.World<S,C,R,E> -> W.World<S,C,R,E> & DTO.Observation<Rows>,~fold:H -> H & List<&2,Fields.Fields<S>>,~Ids:Data,~declaration:Condition.Program<S,C,R,E,Ids>,~Error:Data,~dispatch:H -> W.World<S,C,R,E> -> U32 -> H & Sys.Outcome<W.World<S,C,R,E>,Error,Unit>,~provision:W.World<S,C,R,E> -> W.World<S,C,R,E> & List<&2,SP.Requirement<S>>,app:Application<S,C,R,E,H,Rows,observe,fold,Ids,declaration>) -> Schedule.RunResult<Application<S,C,R,E,H,Rows,observe,fold,Ids,declaration>,S,Error>:
88	  match app:
89	    case Application{scheduled,program}:executed(~S,~C,~R,~E,~H,~Rows,~observe,~fold,~Ids,~declaration,~Error,program,Schedule.run(~S,~C,~R,~E,~H,~Rows,~observe,~fold,~Error,~dispatch,~Condition.evaluator(~S,~C,~R,~E,~Ids,declaration),~provision,scheduled))