ordinary_app_schedule.bend
bendvy-ecs-core@0.1.0.0 · 163 lines · 0 definitions
1import Base
2import bendvy-ecs-core@0.1.0.0/ordinary_condition_composition.bend as Comp
3import ordinary_app_recipe.bend as Tree
4import ordinary_app_schema.bend as App
5import ordinary_app_composer.bend as Build
6import ordinary_app_registration_fields.bend as Records
7import ordinary_app_observation_data.bend as DTO
8import ordinary_schema.bend as Schema
9import world.bend as W
10import system.bend as Sys
11import schedule.bend as Sch
12import schedule_provision.bend as SP
13# Plan is ordinary operational input; only enabled snapshots lower its description.
14# Detached schedule step plus its declared provisioning requirements.
15# Description order follows the operational plan, including explicit barriers.
16type PlannedStep<S:Data> is Data:
17 PlannedStep{step:Sch.Step,requirements:List<&2,SP.Requirement<S>>}
18# Detached enabled-debug view of an application and its selected schedule.
19# Contains observations and metadata, not affine owners or a restorable save.
20type Description<S:Data,Rows:Data> is Data:
21 Description{application:App.Description<S,Rows>,namespace:U32,name:String,steps:List<&2,PlannedStep<S>>}
22# An application with an explicit validated schedule and its retained owners.
23# This lower-level layer requires dispatch/condition/provision callbacks on run;
24# ordinary-app-run derives those callbacks from existing registrations.
25type 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,Records.Fields<S>>> is Type:
26 Application{app:App.Application<S,C,R,E,H,Rows,observe,fold>,plan:SP.Plan<S>,namespace:U32,name:String,steps:List<&2,Sch.Step>,needs:List<&2,SP.Requirement<S>>}
27# Schedule attachment returns Attached with the scheduled owner or Invalid
28# with the original application owner. Refusal does not discard the application.
29type Attachment<-Original:Type,-Scheduled:Type> is Type:
30 Attached{app:Scheduled}
31 Invalid{app:Original}
32# Outcome retaining the affine application in every branch. Finished carries
33# schedule observations; Failed also carries the system/condition error;
34# Rejected denotes schedule refusal; Missing lists unavailable requirements.
35# Failed execution can retain earlier committed systems; it is not whole-run rollback.
36type RunResult<-A:Type,-S:Data,-Error:Data> is Type:
37 Finished{app:A,observations:List<&2,Sch.Observation>}
38 Failed{app:A,error:Error,observations:List<&2,Sch.Observation>}
39 Rejected{app:A}
40 Missing{app:A,requirements:List<&2,SP.Requirement<S>>}
41def planned(~S:Data,plan:SP.Plan<S>) -> List<&2,PlannedStep<S>>:
42 match plan:
43 case SP.Empty{}:[]
44 case SP.Entry{step,needs}:[PlannedStep{step,needs}]
45 case SP.Sequence{left,right}:List.append(&2,PlannedStep<S>,planned(~S,left),planned(~S,right))
46def ids(registrations:List<&2,W.RegistrationMeta>) -> List<&2,U32>:
47 match registrations:
48 case []:[]
49 case W.RegistrationMeta{id,_,_} <> rest:id <> ids(rest)
50def catalog(~S:Data,~C:Type,~R:Type,~E:Data,world:W.World<S,C,R,E>) -> W.World<S,C,R,E> & (U32 & List<&2,U32>):
51 match world:
52 case W.World{+namespace,allocator,store,resource,events,pending,+registrations,nextSystemId,clock}:(W.World{namespace,allocator,store,resource,events,pending,registrations,nextSystemId,clock},(namespace,ids(registrations)))
53def built(~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,Records.Fields<S>>,schema:Schema.Schema<S,C,R>,world:W.World<S,C,R,E>,recipe:Tree.Recipe<W.World<S,C,R,E>,Rows,observe>,debug:Bool,+plan:SP.Plan<S>,result:SP.Build<S,C,R,E,H>) -> Attachment<App.Application<S,C,R,E,H,Rows,observe,fold>,Application<S,C,R,E,H,Rows,observe,fold>>:
54 match result:
55 case SP.Invalid{owners}:Invalid{App.Application{schema,Build.Registered{world,owners,recipe,debug}}}
56 case SP.Built{SP.Provisioned{Sch.Schedule{namespace,name,steps,owners},needs}}:Attached{Application{App.Application{schema,Build.Registered{world,owners,recipe,debug}},plan,namespace,name,steps,needs}}
57def cataloged(~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,Records.Fields<S>>,schema:Schema.Schema<S,C,R>,owners:H,recipe:Tree.Recipe<W.World<S,C,R,E>,Rows,observe>,debug:Bool,+plan:SP.Plan<S>,name:String,result:W.World<S,C,R,E> & (U32 & List<&2,U32>)) -> Attachment<App.Application<S,C,R,E,H,Rows,observe,fold>,Application<S,C,R,E,H,Rows,observe,fold>>:
58 match result:
59 case (world,(namespace,known)):built(~S,~C,~R,~E,~H,~Rows,~observe,~fold,schema,world,recipe,debug,plan,SP.build(~S,~C,~R,~E,~H,namespace,name,plan,known,owners))
60# Attach an explicit operational plan to an application, validating steps
61# against its current registration catalog. Returns Attached or Invalid with
62# the original owner. Does not execute bodies or flush pending commands.
63# Prefer ordinary-app-run.attach for a plan derived from registrations.
64def 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,Records.Fields<S>>,app:App.Application<S,C,R,E,H,Rows,observe,fold>,name:String,plan:SP.Plan<S>) -> Attachment<App.Application<S,C,R,E,H,Rows,observe,fold>,Application<S,C,R,E,H,Rows,observe,fold>>:
65 match app:
66 case App.Application{schema,Build.Registered{world,owners,recipe,debug}}:cataloged(~S,~C,~R,~E,~H,~Rows,~observe,~fold,schema,owners,recipe,debug,plan,name,catalog(~S,~C,~R,~E,world))
67# Return the scheduled application with debug toggled; preserve its world,
68# plan and invocation owners. This call does not run or inspect any system.
69def 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,Records.Fields<S>>,value:Application<S,C,R,E,H,Rows,observe,fold>,flag:Bool) -> Application<S,C,R,E,H,Rows,observe,fold>:
70 match value:
71 case Application{app,plan,namespace,name,steps,needs}:Application{App.enabled(~S,~C,~R,~E,~H,~Rows,~observe,~fold,app,flag),plan,namespace,name,steps,needs}
72def 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,Records.Fields<S>>,+plan:SP.Plan<S>,+namespace:U32,+name:String,steps:List<&2,Sch.Step>,needs:List<&2,SP.Requirement<S>>,result:App.Application<S,C,R,E,H,Rows,observe,fold> & Maybe<&2,App.Description<S,Rows>>) -> Application<S,C,R,E,H,Rows,observe,fold> & Maybe<&2,Description<S,Rows>>:
73 match result:
74 case (app,None{}):(Application{app,plan,namespace,name,steps,needs},None{})
75 case (app,Some{view}):(Application{app,plan,namespace,name,steps,needs},Some{Description{view,namespace,name,planned(~S,plan)}})
76# Return the retained application and an optional detached debug description.
77# Disabled debug yields None. Enabled observation describes the operational
78# plan without running it or consuming system lifecycle/event cursors.
79# Example: examples/scheduled-health/registration.bend uses ordinary-app-run.snapshot.
80def 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,Records.Fields<S>>,value:Application<S,C,R,E,H,Rows,observe,fold>) -> Application<S,C,R,E,H,Rows,observe,fold> & Maybe<&2,Description<S,Rows>>:
81 match value:
82 case Application{app,plan,namespace,name,steps,needs}:observed(~S,~C,~R,~E,~H,~Rows,~observe,~fold,plan,namespace,name,steps,needs,App.snapshot(~S,~C,~R,~E,~H,~Rows,~observe,~fold,app))
83def 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,Records.Fields<S>>,~Error:Data,schema:Schema.Schema<S,C,R>,recipe:Tree.Recipe<W.World<S,C,R,E>,Rows,observe>,debug:Bool,plan:SP.Plan<S>,needs:List<&2,SP.Requirement<S>>,result:Sch.RunResult<S,C,R,E,H,Error>) -> RunResult<Application<S,C,R,E,H,Rows,observe,fold>,S,Error>:
84 match result:
85 case Sch.Finished{Sch.Schedule{namespace,name,steps,owners},world,observations}:Finished{Application{App.Application{schema,Build.Registered{world,owners,recipe,debug}},plan,namespace,name,steps,needs},observations}
86 case Sch.Failed{Sch.Schedule{namespace,name,steps,owners},world,error,observations}:Failed{Application{App.Application{schema,Build.Registered{world,owners,recipe,debug}},plan,namespace,name,steps,needs},error,observations}
87 case Sch.Rejected{Sch.Schedule{namespace,name,steps,owners},world}:Rejected{Application{App.Application{schema,Build.Registered{world,owners,recipe,debug}},plan,namespace,name,steps,needs}}
88def provisioned(~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,Records.Fields<S>>,~Error:Data,schema:Schema.Schema<S,C,R>,recipe:Tree.Recipe<W.World<S,C,R,E>,Rows,observe>,debug:Bool,plan:SP.Plan<S>,result:SP.ProvisionResult<S,C,R,E,H,Error>) -> RunResult<Application<S,C,R,E,H,Rows,observe,fold>,S,Error>:
89 match result:
90 case SP.Missing{SP.Provisioned{Sch.Schedule{namespace,name,steps,owners},needs},world,missing}:Missing{Application{App.Application{schema,Build.Registered{world,owners,recipe,debug}},plan,namespace,name,steps,needs},missing}
91 case SP.Executed{result,needs}:executed(~S,~C,~R,~E,~H,~Rows,~observe,~fold,~Error,schema,recipe,debug,plan,needs,result)
92# Advanced execution of an explicit schedule with supplied callbacks. Checks
93# provisioned requirements before steps; all result variants retain the App.
94# Systems execute in plan order; only explicit barriers apply deferred work.
95# dispatch/condition/provision are trusted world-threading callbacks; arbitrary
96# callback mutations or host IO are not automatically transactional. Prefer
97# ordinary-app-run.run for registration-derived ordinary execution.
98def 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,Records.Fields<S>>,~Error:Data,~dispatch:H -> W.World<S,C,R,E> -> U32 -> H & Sys.Outcome<W.World<S,C,R,E>,Error,Unit>,~condition:W.World<S,C,R,E> -> U32 -> W.World<S,C,R,E> & Bool,~provision:W.World<S,C,R,E> -> W.World<S,C,R,E> & List<&2,SP.Requirement<S>>,value:Application<S,C,R,E,H,Rows,observe,fold>) -> RunResult<Application<S,C,R,E,H,Rows,observe,fold>,S,Error>:
99 match value:
100 case Application{App.Application{schema,Build.Registered{world,owners,recipe,debug}},plan,namespace,name,steps,needs}:provisioned(~S,~C,~R,~E,~H,~Rows,~observe,~fold,~Error,schema,recipe,debug,plan,SP.run(~S,~C,~R,~E,~H,~Error,~dispatch,~condition,~provision,SP.Provisioned{Sch.Schedule{namespace,name,steps,owners},needs},world))
101
102# Stateful guards are retained beside the same ordinary App, not in its resources.
103# Scheduled application retaining affine condition bindings beside system
104# owners, outside resource storage. Guard state is returned with the App,
105# including skip/failure; it is not reset by rolling back a system transaction.
106type ConditionedApplication<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,Records.Fields<S>>,B:Type,-select:B -> W.World<S,C,R,E> -> U32 -> Comp.Evaluation<W.World<S,C,R,E>,B>> is Type:
107 ConditionedApplication{app:Application<S,C,R,E,H,Rows,observe,fold>,bindings:Comp.Bindings<W.World<S,C,R,E>,B,select>}
108# Guard attachment returns ConditionsAttached or ConditionsInvalid.
109# Refusal returns both the original application and the condition bindings,
110# preserving their separate affine owners for retry or disposal.
111type ConditionAttachment<-Original:Type,-Guards:Type,-Scheduled:Type> is Type:
112 ConditionsAttached{app:Scheduled}
113 ConditionsInvalid{app:Original,bindings:Guards}
114# Detached debug description of the underlying application plus ordered
115# condition-binding descriptions; contains no live condition owners.
116type ConditionDescription<S:Data,Rows:Data> is Data:
117 ConditionDescription{original:Description<S,Rows>,bindings:List<&2,Comp.BindingDescription>}
118def conditions_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,Records.Fields<S>>,~B:Type,~select:B -> W.World<S,C,R,E> -> U32 -> Comp.Evaluation<W.World<S,C,R,E>,B>,schema:Schema.Schema<S,C,R>,world:W.World<S,C,R,E>,recipe:Tree.Recipe<W.World<S,C,R,E>,Rows,observe>,debug:Bool,plan:SP.Plan<S>,needs:List<&2,SP.Requirement<S>>,result:Comp.Attachment<S,C,R,E,H,B,select>) -> ConditionAttachment<Application<S,C,R,E,H,Rows,observe,fold>,Comp.Bindings<W.World<S,C,R,E>,B,select>,ConditionedApplication<S,C,R,E,H,Rows,observe,fold,B,select>>:
119 match result:
120 case Comp.Attached{Sch.Schedule{namespace,name,steps,(owners,bindings)}}:ConditionsAttached{ConditionedApplication{Application{App.Application{schema,Build.Registered{world,owners,recipe,debug}},plan,namespace,name,steps,needs},bindings}}
121 case Comp.AttachmentRejected{Sch.Schedule{namespace,name,steps,owners},bindings}:ConditionsInvalid{Application{App.Application{schema,Build.Registered{world,owners,recipe,debug}},plan,namespace,name,steps,needs},bindings}
122# Attach typed condition owners by actual scheduled system ID. Duplicate
123# bindings and targets absent from the schedule refuse attachment; refusal
124# returns both App and bindings. Does not evaluate guards or run system bodies.
125# A scheduled system with no binding is unconditional, not implicitly skipped.
126def attach_conditions(~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,Records.Fields<S>>,~B:Type,~select:B -> W.World<S,C,R,E> -> U32 -> Comp.Evaluation<W.World<S,C,R,E>,B>,value:Application<S,C,R,E,H,Rows,observe,fold>,bindings:Comp.Bindings<W.World<S,C,R,E>,B,select>) -> ConditionAttachment<Application<S,C,R,E,H,Rows,observe,fold>,Comp.Bindings<W.World<S,C,R,E>,B,select>,ConditionedApplication<S,C,R,E,H,Rows,observe,fold,B,select>>:
127 match value:
128 case Application{App.Application{schema,Build.Registered{world,owners,recipe,debug}},plan,namespace,name,steps,needs}:conditions_attached(~S,~C,~R,~E,~H,~Rows,~observe,~fold,~B,~select,schema,world,recipe,debug,plan,needs,Comp.attach(~S,~C,~R,~E,~H,~B,~select,Sch.Schedule{namespace,name,steps,owners},bindings))
129# Toggle debug while retaining the same scheduled App and condition owners.
130# Does not evaluate or reset condition state.
131def enabled_conditions(~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,Records.Fields<S>>,~B:Type,~select:B -> W.World<S,C,R,E> -> U32 -> Comp.Evaluation<W.World<S,C,R,E>,B>,value:ConditionedApplication<S,C,R,E,H,Rows,observe,fold,B,select>,flag:Bool) -> ConditionedApplication<S,C,R,E,H,Rows,observe,fold,B,select>:
132 match value:
133 case ConditionedApplication{app,bindings}:ConditionedApplication{enabled(~S,~C,~R,~E,~H,~Rows,~observe,~fold,app,flag),bindings}
134def conditions_snapshot_present(~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,Records.Fields<S>>,~B:Type,~select:B -> W.World<S,C,R,E> -> U32 -> Comp.Evaluation<W.World<S,C,R,E>,B>,app:Application<S,C,R,E,H,Rows,observe,fold>,view:Description<S,Rows>,bindings:Comp.Bindings<W.World<S,C,R,E>,B,select>) -> ConditionedApplication<S,C,R,E,H,Rows,observe,fold,B,select> & Maybe<&2,ConditionDescription<S,Rows>>:
135 match bindings:
136 case Comp.Bindings{owner,+facts}:(ConditionedApplication{app,Comp.Bindings{owner,facts}},Some{ConditionDescription{view,facts}})
137def conditions_snapshot_returned(~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,Records.Fields<S>>,~B:Type,~select:B -> W.World<S,C,R,E> -> U32 -> Comp.Evaluation<W.World<S,C,R,E>,B>,bindings:Comp.Bindings<W.World<S,C,R,E>,B,select>,observed:Application<S,C,R,E,H,Rows,observe,fold> & Maybe<&2,Description<S,Rows>>) -> ConditionedApplication<S,C,R,E,H,Rows,observe,fold,B,select> & Maybe<&2,ConditionDescription<S,Rows>>:
138 match observed:
139 case (app,None{}):(ConditionedApplication{app,bindings},None{})
140 case (app,Some{view}):conditions_snapshot_present(~S,~C,~R,~E,~H,~Rows,~observe,~fold,~B,~select,app,view,bindings)
141# Return the conditioned App with detached descriptions only when enabled.
142# Neither guard evaluation nor system execution is performed; affine binding
143# owners and registered visibility cursors are retained.
144def snapshot_conditions(~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,Records.Fields<S>>,~B:Type,~select:B -> W.World<S,C,R,E> -> U32 -> Comp.Evaluation<W.World<S,C,R,E>,B>,value:ConditionedApplication<S,C,R,E,H,Rows,observe,fold,B,select>) -> ConditionedApplication<S,C,R,E,H,Rows,observe,fold,B,select> & Maybe<&2,ConditionDescription<S,Rows>>:
145 match value:
146 case ConditionedApplication{app,bindings}:conditions_snapshot_returned(~S,~C,~R,~E,~H,~Rows,~observe,~fold,~B,~select,bindings,snapshot(~S,~C,~R,~E,~H,~Rows,~observe,~fold,app))
147def conditions_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,Records.Fields<S>>,~B:Type,~select:B -> W.World<S,C,R,E> -> U32 -> Comp.Evaluation<W.World<S,C,R,E>,B>,~BodyError:Data,~dispatch:H -> W.World<S,C,R,E> -> U32 -> H & Sys.Outcome<W.World<S,C,R,E>,BodyError,Unit>,schema:Schema.Schema<S,C,R>,recipe:Tree.Recipe<W.World<S,C,R,E>,Rows,observe>,debug:Bool,plan:SP.Plan<S>,needs:List<&2,SP.Requirement<S>>,result:Sch.RunResult<S,C,R,E,H & Comp.Bindings<W.World<S,C,R,E>,B,select>,Comp.Error<BodyError>>) -> RunResult<ConditionedApplication<S,C,R,E,H,Rows,observe,fold,B,select>,S,Comp.Error<BodyError>>:
148 match result:
149 case Sch.Finished{Sch.Schedule{namespace,name,steps,(owners,bindings)},world,observations}:Finished{ConditionedApplication{Application{App.Application{schema,Build.Registered{world,owners,recipe,debug}},plan,namespace,name,steps,needs},bindings},observations}
150 case Sch.Failed{Sch.Schedule{namespace,name,steps,(owners,bindings)},world,error,observations}:Failed{ConditionedApplication{Application{App.Application{schema,Build.Registered{world,owners,recipe,debug}},plan,namespace,name,steps,needs},bindings},error,observations}
151 case Sch.Rejected{Sch.Schedule{namespace,name,steps,(owners,bindings)},world}:Rejected{ConditionedApplication{Application{App.Application{schema,Build.Registered{world,owners,recipe,debug}},plan,namespace,name,steps,needs},bindings}}
152def conditions_provisioned(~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,Records.Fields<S>>,~B:Type,~select:B -> W.World<S,C,R,E> -> U32 -> Comp.Evaluation<W.World<S,C,R,E>,B>,~BodyError:Data,~dispatch:H -> W.World<S,C,R,E> -> U32 -> H & Sys.Outcome<W.World<S,C,R,E>,BodyError,Unit>,schema:Schema.Schema<S,C,R>,recipe:Tree.Recipe<W.World<S,C,R,E>,Rows,observe>,debug:Bool,plan:SP.Plan<S>,result:SP.ProvisionResult<S,C,R,E,H & Comp.Bindings<W.World<S,C,R,E>,B,select>,Comp.Error<BodyError>>) -> RunResult<ConditionedApplication<S,C,R,E,H,Rows,observe,fold,B,select>,S,Comp.Error<BodyError>>:
153 match result:
154 case SP.Missing{SP.Provisioned{Sch.Schedule{namespace,name,steps,(owners,bindings)},needs},world,missing}:Missing{ConditionedApplication{Application{App.Application{schema,Build.Registered{world,owners,recipe,debug}},plan,namespace,name,steps,needs},bindings},missing}
155 case SP.Executed{result,needs}:conditions_executed(~S,~C,~R,~E,~H,~Rows,~observe,~fold,~B,~select,~BodyError,~dispatch,schema,recipe,debug,plan,needs,result)
156# Execute with retained typed guard bindings and explicit provisioning.
157# False skips the body; unavailable/rejected conditions stop with their typed
158# error. Earlier successful steps and returned guard state remain retained.
159# No binding means unconditional execution; barriers alone apply deferred work.
160# Every RunResult branch returns the conditioned application owner.
161def run_conditions(~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,Records.Fields<S>>,~B:Type,~select:B -> W.World<S,C,R,E> -> U32 -> Comp.Evaluation<W.World<S,C,R,E>,B>,~BodyError:Data,~dispatch:H -> W.World<S,C,R,E> -> U32 -> H & Sys.Outcome<W.World<S,C,R,E>,BodyError,Unit>,~provision:W.World<S,C,R,E> -> W.World<S,C,R,E> & List<&2,SP.Requirement<S>>,value:ConditionedApplication<S,C,R,E,H,Rows,observe,fold,B,select>) -> RunResult<ConditionedApplication<S,C,R,E,H,Rows,observe,fold,B,select>,S,Comp.Error<BodyError>>:
162 match value:
163 case ConditionedApplication{Application{App.Application{schema,Build.Registered{world,owners,recipe,debug}},plan,namespace,name,steps,needs},bindings}:conditions_provisioned(~S,~C,~R,~E,~H,~Rows,~observe,~fold,~B,~select,~BodyError,~dispatch,schema,recipe,debug,plan,Comp.run_provisioned(~S,~C,~R,~E,~H,~B,~select,~BodyError,~dispatch,~provision,SP.Provisioned{Sch.Schedule{namespace,name,steps,(owners,bindings)},needs},world))