new module structure

.github/workflows/build-and-test.yml

@@ -6,6 +6,11 @@ on:
 jobs:
   taurus:
     runs-on: ubuntu-latest
+    services:
+      nats:
+        image: nats:2
+        ports:
+          - 4222:4222
 
     steps:
       - uses: actions/checkout@v6
@@ -15,8 +20,11 @@ jobs:
         run: PATH=${{ runner.temp }}/proto/bin:$PATH cargo build
         env:
           RUST_BACKTRACE: 'full'
-      - name: Run Tests
-        run: cargo test
-      - name: Run Test Suite
+      - name: Run workspace tests
+        run: cargo test --workspace --all-targets
+      - name: Run NATS test execution request tests
+        run: cargo test -p taurus test_execution_request -- --ignored --nocapture
+        env:
+          NATS_URL: nats://127.0.0.1:4222
+      - name: Run tests package flow suite
         run: cargo run --package tests
-

Cargo.toml

@@ -9,7 +9,7 @@ edition = "2024"
 [workspace.dependencies]
 async-trait = "0.1.89"
 code0-flow = { version = "0.0.33" }
-tucana = { version = "0.0.68" }
+tucana = { version = "0.0.70" }
 tokio = { version = "1.44.1", features = ["rt-multi-thread", "signal"] }
 log = "0.4.27"
 futures-lite = "2.6.0"

crates/taurus-core/src/handler/argument.rs

@@ -7,12 +7,56 @@ use tucana::shared::value::Kind;
 use tucana::shared::{ListValue, NumberValue, Struct, Value};
 
 use crate::value::{number_to_f64, number_to_i64_lossy};
+use std::fmt;
+use tucana::shared::SubFlowSetting;
+
+#[derive(Clone)]
+pub struct FunctionThunk {
+    pub identifier: String,
+    pub parameter_index: i64,
+    pub settings: Vec<SubFlowSetting>,
+}
+
+impl fmt::Debug for FunctionThunk {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("FunctionThunk")
+            .field("identifier", &self.identifier)
+            .field("parameter_index", &self.parameter_index)
+            .field("settings_len", &self.settings.len())
+            .finish()
+    }
+}
+
+#[derive(Clone)]
+pub enum Thunk {
+    Node(i64),
+    Function(FunctionThunk),
+}
+
+impl fmt::Debug for Thunk {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Thunk::Node(node_id) => write!(f, "{}", node_id),
+            Thunk::Function(function) => function.fmt(f),
+        }
+    }
+}
+
+impl Thunk {
+    pub fn trace_target(&self) -> String {
+        match self {
+            Thunk::Node(node_id) => format!("node={}", node_id),
+            Thunk::Function(function) => format!("function={}", function.identifier),
+        }
+    }
+}
+
 #[derive(Clone, Debug)]
 pub enum Argument {
     /// Eager value that can be consumed immediately by a handler.
     Eval(Value),
-    /// Deferred node execution handle, evaluated by calling `run(node_id)`.
-    Thunk(i64),
+    /// Deferred execution handle, evaluated by calling `run(thunk)`.
+    Thunk(Thunk),
 }
 
 #[derive(Clone, Copy, Debug)]

crates/taurus-core/src/handler/registry.rs

@@ -1,19 +1,21 @@
 //! Runtime handler registry and callable function signatures.
 
-use crate::handler::argument::{Argument, ParameterNode};
+use crate::handler::argument::{Argument, ParameterNode, Thunk};
 use crate::runtime::execution::value_store::ValueStore;
 use crate::runtime::functions::ALL_FUNCTION_SETS;
 use crate::types::signal::Signal;
 use std::collections::HashMap;
 
 /// Handler function type.
 /// - For eager params, the executor will already convert them to Argument::Eval(Value).
-/// - For lazy params, the executor will pass Argument::Thunk(node_id).
-/// - If a handler wants to execute a lazy arg, it calls run(node_id).
-pub type HandlerFn = fn(
+/// - For lazy params, the executor will pass Argument::Thunk(thunk).
+/// - If a handler wants to execute a lazy arg, it calls run(thunk).
+pub type ThunkRunner<'runner> = dyn FnMut(&Thunk, &mut ValueStore) -> Signal + 'runner;
+
+pub type HandlerFn = for<'runner> fn(
     args: &[Argument],
     ctx: &mut ValueStore,
-    run: &mut dyn FnMut(i64, &mut ValueStore) -> Signal,
+    run: &mut ThunkRunner<'runner>,
 ) -> Signal;
 
 #[derive(Clone, Copy)]

crates/taurus-core/src/lib.rs

@@ -5,5 +5,6 @@
 
 mod handler;
 pub mod runtime;
+pub mod time;
 pub mod types;
 pub mod value;