1use super::registry::*;
2use crate::{
3 bind::Host,
4 error::Diagnostic,
5 eval::{Engine, Env},
6 span::Span,
7 value::Value,
8};
9use std::collections::BTreeMap;
10
11struct ExecutionClaim {
13 _scope: TaskScope,
14 id: u64,
15}
16impl Drop for ExecutionClaim {
17 fn drop(&mut self) {
18 if let Ok(mut tasks) = registry().lock() {
19 if let Some(entry) = tasks.get_mut(&self.id) {
20 executor_checkpoint(entry);
21 if entry.state == State::Running {
22 entry.state = State::Failed;
23 entry.failure =
24 Some("task execution unwound; prior effects require reconciliation".into());
25 }
26 }
27 }
28 }
29}
30
31pub fn await_scheduled_value<H: Host>(
32 engine: &mut Engine<'_, H>,
33 value: Value,
34 env: &mut Env,
35 span: Span,
36) -> Result<Value, Diagnostic> {
37 match value {
38 Value::Record(rec) if is_task_record(&rec) => join(engine, env, Value::Record(rec), span),
39 Value::Lambda { params, body } if params.is_empty() => engine.eval_expr(&body, env),
40 other => Ok(other),
41 }
42}
43
44fn join<H: Host>(
45 engine: &mut Engine<'_, H>,
46 env: &mut Env,
47 handle: Value,
48 span: Span,
49) -> Result<Value, Diagnostic> {
50 if engine.active_tasks.len() >= 8 {
51 return Err(error(span, "nested synchronous task limit exceeded (8)"));
52 }
53 let scope = env.task_scope.clone();
54 let (id, source) = {
55 let mut tasks = registry()
56 .lock()
57 .map_err(|_| error(span, "task registry is poisoned"))?;
58 let entry = owned(&scope, &mut tasks, &handle, span)?;
59 refresh_observer(entry);
60 match entry.state {
61 State::Completed => return Ok(record(entry)),
62 State::Running => return Err(error(
63 span,
64 "task already has an executor; synchronous await cannot suspend or run it twice",
65 )),
66 State::Cancelled | State::TimedOut | State::Failed => {
67 return Err(error(
68 span,
69 entry
70 .failure
71 .as_deref()
72 .unwrap_or("task is terminal without a successful result"),
73 ))
74 }
75 State::Pending => {}
76 }
77 entry.state = State::Running;
78 (entry.id, entry.code.clone())
79 };
80 let claim = ExecutionClaim {
81 _scope: scope.clone(),
82 id,
83 };
84 let pinned_registry_gen = engine.extension_registry.generation();
85 let pinned_policy_gen = engine
86 .sentinel_gate
87 .as_ref()
88 .map(|g| g.current_policy_generation());
89 engine.active_tasks.push((scope.clone(), id));
90 let output = execute(engine, env, &source, span);
91 engine.active_tasks.pop();
92 let output = output.and_then(|value| {
93 if engine.extension_registry.generation() != pinned_registry_gen {
94 return Err(crate::extension_registry::trap_to_diagnostic(
95 vibescript_abi::VibeTrap::StaleRegistryGeneration,
96 "task.await",
97 span,
98 ));
99 }
100 if engine
101 .sentinel_gate
102 .as_ref()
103 .map(|g| g.current_policy_generation())
104 != pinned_policy_gen
105 {
106 return Err(crate::extension_registry::trap_to_diagnostic(
107 vibescript_abi::VibeTrap::MidExecutionPolicyRevoked,
108 "task.await",
109 span,
110 ));
111 }
112 let bytes = retained_bytes(&value, span)?;
113 engine.charge_task_source((bytes as u64).saturating_mul(2), span)?;
114 Ok((value, bytes))
115 });
116 let mut tasks = registry()
117 .lock()
118 .map_err(|_| error(span, "task registry is poisoned"))?;
119 let output = output.and_then(|(value, bytes)| {
120 admit_bytes(&scope, &tasks, bytes, span)?;
121 Ok((value, bytes))
122 });
123 let entry = owned(&scope, &mut tasks, &handle, span)?;
124 executor_checkpoint(entry); if entry.state != State::Running {
126 return Err(error(
127 span,
128 "task cancelled or deadline expired; prior external effects may require reconciliation",
129 ));
130 }
131 match output {
132 Ok((value, bytes)) => {
133 entry.retained_bytes += bytes;
134 entry.result = Some(value);
135 entry.state = State::Completed;
136 }
137 Err(diag) => {
138 entry.failure = Some(diag.message.clone());
139 entry.state = State::Failed;
140 return Err(diag);
141 }
142 }
143 let result = record(entry);
144 drop(tasks);
145 drop(claim);
146 Ok(result)
147}
148
149fn execute<H: Host>(
150 engine: &mut Engine<'_, H>,
151 env: &mut Env,
152 source: &str,
153 span: Span,
154) -> Result<Value, Diagnostic> {
155 let resolved;
156 let source = if source.trim().starts_with("sha256:") {
157 resolved = crate::stdlib_v2::topology_and_manifold::effects_and_systems::lookup_verified_ast_source(source.trim())
158 .ok_or_else(|| error(span, "task content-addressed source is unavailable or failed verification"))?;
159 resolved.trim()
160 } else {
161 source.trim()
162 };
163 if source.len() > 65_536 {
164 return Err(error(span, "resolved task source exceeds 65536 bytes"));
165 }
166 let explicit_cell = crate::parse_cell(source);
170 if let Ok(expression) = explicit_cell {
171 crate::check_cell(&expression)?;
172 return engine.eval_expr(&expression, env);
173 }
174 match crate::parse_program(source) {
175 Ok(program) => {
176 crate::check_program(&program)?;
177 engine.eval_task_program(&program, env, span)
178 }
179 Err(program_error) => {
180 let expression = match crate::parse_cell(&format!("= {source}")) {
183 Ok(expression) => expression,
184 Err(_) => return Err(program_error),
185 };
186 crate::check_cell(&expression)?;
187 engine.eval_expr(&expression, env)
188 }
189 }
190}
191
192pub(crate) fn dispatch_on_engine<H: Host>(
194 engine: &mut Engine<'_, H>,
195 path: &str,
196 args: &[Value],
197 env: &mut Env,
198 span: Span,
199) -> Result<Option<Value>, Diagnostic> {
200 let scope = env.task_scope.clone();
201 let first = || {
202 args.first()
203 .ok_or_else(|| error(span, "task operation requires an argument"))
204 };
205 let result = match path {
206 "task.spawn" => {
207 let code = first()?
208 .as_str()
209 .ok_or_else(|| error(span, "task.spawn expects source text"))?;
210 engine.charge_task_source(code.len() as u64, span)?;
212 spawn(&scope, code, span)?
213 }
214 "code.spawn_at" => {
215 let node = first()?
216 .as_str()
217 .ok_or_else(|| error(span, "code.spawn_at expects a node identifier"))?;
218 if node != "did:q42:local_scheduler" {
219 return Err(error(
220 span,
221 "remote/provider task launch is unsupported; no admitted provider is connected",
222 ));
223 }
224 let code = args
225 .get(1)
226 .and_then(Value::as_str)
227 .ok_or_else(|| error(span, "code.spawn_at expects source or a verified digest"))?;
228 if code.starts_with("sha256:") && crate::stdlib_v2::topology_and_manifold::effects_and_systems::lookup_verified_ast_source(code).is_none() {
229 return Err(error(span, "content-addressed task source is unavailable"));
230 }
231 engine.charge_task_source(code.len() as u64, span)?;
232 spawn(&scope, code, span)?
233 }
234 "task.await" => await_scheduled_value(engine, first()?.clone(), env, span)?,
235 "task.status" => status(&scope, first()?, span)?,
236 "task.cancel" => cancel(&scope, first()?, span)?,
237 "task.with_timeout" => {
238 let ms = args
239 .get(1)
240 .and_then(Value::as_i64)
241 .ok_or_else(|| error(span, "task.with_timeout expects integer milliseconds"))?;
242 timeout(&scope, first()?, ms, span)?
243 }
244 "task.nursery" => nursery(engine, env, first()?, span)?,
245 _ => return Ok(None),
246 };
247 Ok(Some(result))
248}
249
250fn nursery<H: Host>(
251 engine: &mut Engine<'_, H>,
252 env: &mut Env,
253 input: &Value,
254 span: Span,
255) -> Result<Value, Diagnostic> {
256 let Value::List(tasks) = input else {
257 return Err(error(span, "task.nursery expects task handles"));
258 };
259 if tasks.len() > 256 {
260 return Err(error(span, "task nursery capacity exceeds 256"));
261 }
262 let mut known_failure = false;
264 for task in tasks {
265 let Value::Record(current) = status(&env.task_scope, task, span)? else {
266 unreachable!()
267 };
268 known_failure |= matches!(
269 current.get("status").and_then(Value::as_str),
270 Some("failed" | "cancelled" | "timed_out")
271 );
272 }
273 let mut results = Vec::with_capacity(tasks.len());
274 let mut failure = known_failure
275 .then(|| "nursery already contains a failed, cancelled or timed-out task".to_string());
276 let mut cancelled_count = 0u64;
277 let mut requested_count = 0u64;
278 for task in tasks {
279 if failure.is_some() {
280 let cancelled = cancel(&env.task_scope, task, span)?;
281 if let Value::Record(record) = &cancelled {
282 cancelled_count +=
283 u64::from(record.get("live_job_cancelled") == Some(&Value::Bool(true)));
284 requested_count += u64::from(
285 record.get("cancellation_request_accepted") == Some(&Value::Bool(true)),
286 );
287 }
288 results.push(cancelled);
289 } else {
290 match join(engine, env, task.clone(), span) {
291 Ok(result) => results.push(result),
292 Err(diag) => {
293 failure = Some(diag.message);
294 results.push(status(&env.task_scope, task, span)?);
295 }
296 }
297 }
298 }
299 let mut out = BTreeMap::new();
300 out.insert("all_succeeded".into(), Value::Bool(failure.is_none()));
301 out.insert(
302 "cancelled_siblings".into(),
303 Value::Bool(cancelled_count > 0),
304 );
305 out.insert(
306 "live_siblings_cancelled".into(),
307 Value::U64(cancelled_count),
308 );
309 out.insert(
310 "cancellation_requested".into(),
311 Value::Bool(requested_count > 0),
312 );
313 out.insert(
314 "cancellation_requested_count".into(),
315 Value::U64(requested_count),
316 );
317 out.insert("tasks".into(), Value::List(results));
318 out.insert(
319 "execution_qualification".into(),
320 Value::String("sequential_local_nursery_no_async_suspension".into()),
321 );
322 if let Some(message) = failure {
323 out.insert("error".into(), Value::String(message));
324 }
325 Ok(Value::Record(out))
326}