feat: new exec loop

Author: raphael-goetz

crates/taurus-core/src/runtime/execution/mod.rs

@@ -0,0 +1,11 @@
+//! Runtime execution internals.
+//!
+//! These types are owned by the execution engine lifecycle and are not part of
+//! the transport-level flow contracts.
+
+pub mod registry;
+pub mod render;
+pub mod store;
+pub mod trace;
+pub mod tracer;
+pub mod value_store;

crates/taurus-core/src/runtime/execution/registry.rs

@@ -0,0 +1,19 @@
+//! Registry metadata types for runtime handler discovery.
+
+use std::collections::HashMap;
+
+use crate::types::execution::signature::HandlerSignature;
+
+/// Static registry entry metadata.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct HandlerRegistration {
+    pub handler_id: String,
+    pub signature: HandlerSignature,
+    pub description: Option<String>,
+}
+
+/// Read-only handler metadata registry.
+#[derive(Debug, Clone, Default)]
+pub struct HandlerRegistry {
+    pub handlers: HashMap<String, HandlerRegistration>,
+}

crates/taurus-core/src/runtime/execution/render.rs

@@ -0,0 +1,172 @@
+//! Human-readable trace renderer.
+
+use std::collections::HashMap;
+
+use crate::runtime::execution::trace::{ArgKind, EdgeKind, ExecFrame, Outcome, TraceRun};
+
+fn frame_micros(frame: &ExecFrame) -> Option<u128> {
+    frame
+        .end
+        .map(|end| end.duration_since(frame.start).as_micros())
+}
+
+/// Render a trace as plain-text tree output.
+pub fn render_trace(run: &TraceRun) -> String {
+    let mut by_id: HashMap<u64, &ExecFrame> = HashMap::new();
+    for frame in &run.frames {
+        by_id.insert(frame.frame_id, frame);
+    }
+
+    let mut output = String::new();
+    if let Some(total_us) = total_duration_us(&run.frames) {
+        output.push_str(&format!("Total: {}us\n", total_us));
+    }
+    render_frame(run.root, &by_id, "", true, &mut output);
+    if let Some(total_us) = total_duration_us(&run.frames) {
+        output.push_str(&format!("Summary: total_time={}us\n", total_us));
+    }
+    output
+}
+
+fn render_frame(
+    id: u64,
+    by_id: &HashMap<u64, &ExecFrame>,
+    prefix: &str,
+    is_last: bool,
+    output: &mut String,
+) {
+    let frame = by_id[&id];
+
+    let branch = if prefix.is_empty() {
+        ""
+    } else if is_last {
+        "\\- "
+    } else {
+        "+- "
+    };
+
+    let duration = frame_micros(frame)
+        .map(|us| format!(" ({}us)", us))
+        .unwrap_or_default();
+
+    output.push_str(&format!(
+        "{prefix}{branch}#{frame_id}  node={node_id}  fn={function}{duration}\n",
+        prefix = prefix,
+        branch = branch,
+        frame_id = frame.frame_id,
+        node_id = frame.node_id,
+        function = frame.function_name,
+        duration = duration
+    ));
+
+    for arg in &frame.args {
+        let continuation = if prefix.is_empty() || is_last {
+            "   "
+        } else {
+            "|  "
+        };
+
+        let kind = match &arg.kind {
+            ArgKind::Literal => "lit".to_string(),
+            ArgKind::Reference { reference, hit } => {
+                let suffix = if *hit { "hit" } else { "miss" };
+                format!("ref({:?}, {})", reference, suffix)
+            }
+            ArgKind::Thunk {
+                node_id,
+                eager,
+                executed,
+            } => {
+                let mode = if *eager { "eager" } else { "lazy" };
+                let exec = if *executed { "executed" } else { "deferred" };
+                format!("thunk(node={}, {}, {})", node_id, mode, exec)
+            }
+        };
+
+        output.push_str(&format!(
+            "{prefix}{continuation}   arg[{index}] {kind:<24} {preview}\n",
+            prefix = prefix,
+            continuation = continuation,
+            index = arg.index,
+            kind = kind,
+            preview = arg.preview
+        ));
+    }
+
+    let outcome = match &frame.outcome {
+        Some(Outcome::Success { value_preview }) => format!("[SUCCESS] {}", value_preview),
+        Some(Outcome::Failure { error_preview }) => format!("[FAILURE] {}", error_preview),
+        Some(Outcome::Return { value_preview }) => format!("[RETURN] {}", value_preview),
+        Some(Outcome::Respond { value_preview }) => format!("[RESPOND] {}", value_preview),
+        Some(Outcome::Stop) => "[STOP]".to_string(),
+        None => "...".to_string(),
+    };
+
+    let continuation = if prefix.is_empty() || is_last {
+        "   "
+    } else {
+        "|  "
+    };
+    output.push_str(&format!(
+        "{prefix}{continuation}   => {outcome}\n",
+        prefix = prefix,
+        continuation = continuation,
+        outcome = outcome
+    ));
+
+    if frame.children.is_empty() {
+        return;
+    }
+
+    let mut runtime_idx = 0usize;
+    for (idx, (edge, child_id)) in frame.children.iter().enumerate() {
+        let edge_last = idx + 1 == frame.children.len();
+        let edge_branch = if edge_last { "\\- " } else { "+- " };
+
+        let edge_text = match edge {
+            EdgeKind::Next => "NEXT".to_string(),
+            EdgeKind::EagerCall { arg_index } => format!("eager(arg#{})", arg_index),
+            EdgeKind::RuntimeCall { label } => {
+                runtime_idx += 1;
+                match label {
+                    Some(label_text) => format!("runtime(call #{}) {}", runtime_idx, label_text),
+                    None => format!("runtime(call #{})", runtime_idx),
+                }
+            }
+        };
+
+        output.push_str(&format!(
+            "{prefix}{edge_branch}{edge_text}\n",
+            prefix = prefix,
+            edge_branch = edge_branch,
+            edge_text = edge_text
+        ));
+
+        let child_prefix = format!("{}{}", prefix, if edge_last { "   " } else { "|  " });
+        render_frame(*child_id, by_id, &child_prefix, true, output);
+    }
+}
+
+fn total_duration_us(frames: &[ExecFrame]) -> Option<u128> {
+    let mut start = None;
+    let mut end = None;
+
+    for frame in frames {
+        start = Some(match start {
+            Some(current) if frame.start > current => current,
+            Some(_) | None => frame.start,
+        });
+
+        if let Some(frame_end) = frame.end {
+            end = Some(match end {
+                Some(current) if frame_end < current => current,
+                Some(_) | None => frame_end,
+            });
+        }
+    }
+
+    match (start, end) {
+        (Some(start_time), Some(end_time)) => Some(end_time.duration_since(start_time).as_micros()),
+        _ => None,
+    }
+}

crates/taurus-core/src/runtime/execution/store.rs

@@ -0,0 +1,33 @@
+//! Mutable execution state for a single flow run.
+
+use std::collections::HashMap;
+
+use tucana::shared::Value;
+
+use crate::types::errors::runtime_error::RuntimeError;
+use crate::types::execution::ids::{FrameId, NodeId};
+
+/// Runtime outcome persisted per node.
+#[derive(Debug, Clone)]
+pub enum NodeOutcome {
+    Success(Value),
+    Failure(RuntimeError),
+}
+
+/// Input slot key for runtime-provided temporary inputs (for iterators/predicates).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct InputSlotKey {
+    pub node_id: NodeId,
+    pub parameter_index: i32,
+    pub input_index: i32,
+}
+
+/// Store that captures mutable runtime execution state.
+#[derive(Debug, Clone, Default)]
+pub struct ExecutionStore {
+    pub node_outcomes: HashMap<NodeId, NodeOutcome>,
+    pub input_slots: HashMap<InputSlotKey, Value>,
+    pub flow_input: Option<Value>,
+    pub current_node: Option<NodeId>,
+    pub frame_stack: Vec<FrameId>,
+}

crates/taurus-core/src/runtime/execution/trace.rs

@@ -0,0 +1,85 @@
+//! Runtime execution trace model.
+//!
+//! This model captures node frames, argument resolution, control-flow edges,
+//! and final outcomes for one execution run.
+
+use std::time::Instant;
+
+/// Relationship between two execution frames.
+#[derive(Debug, Clone)]
+pub enum EdgeKind {
+    /// Sequential flow transition via `next_node_id`.
+    Next,
+    /// Eager argument child execution.
+    EagerCall { arg_index: usize },
+    /// Lazy runtime callback child execution.
+    RuntimeCall { label: Option<String> },
+}
+
+/// Argument classification for tracing.
+#[derive(Debug, Clone)]
+pub enum ArgKind {
+    Literal,
+    Reference {
+        reference: ReferenceKind,
+        hit: bool,
+    },
+    Thunk {
+        node_id: i64,
+        eager: bool,
+        executed: bool,
+    },
+}
+
+/// Reference source kind for argument tracing.
+#[derive(Debug, Clone)]
+pub enum ReferenceKind {
+    Result {
+        node_id: i64,
+    },
+    InputType {
+        node_id: i64,
+        input_index: i64,
+        parameter_index: i64,
+    },
+    FlowInput,
+    Empty,
+}
+
+/// One traced argument on a frame.
+#[derive(Debug, Clone)]
+pub struct ArgTrace {
+    pub index: usize,
+    pub kind: ArgKind,
+    pub preview: String,
+}
+
+/// Final outcome of a frame.
+#[derive(Debug, Clone)]
+pub enum Outcome {
+    Success { value_preview: String },
+    Failure { error_preview: String },
+    Return { value_preview: String },
+    Respond { value_preview: String },
+    Stop,
+}
+
+/// One executed node invocation.
+#[derive(Debug, Clone)]
+pub struct ExecFrame {
+    pub frame_id: u64,
+    pub node_id: i64,
+    pub function_name: String,
+    pub args: Vec<ArgTrace>,
+    pub outcome: Option<Outcome>,
+    pub start: Instant,
+    pub end: Option<Instant>,
+    pub children: Vec<(EdgeKind, u64)>,
+}
+
+/// Trace data for a full execution.
+#[derive(Debug, Clone)]
+pub struct TraceRun {
+    pub frames: Vec<ExecFrame>,
+    pub root: u64,
+}