spawn sync / bytes

Author: colinrozzi

Cargo.lock

@@ -12,6 +12,7 @@ members = [
     "crates/theater-handler-store",
     "crates/theater-handler-supervisor",
     "crates/theater-handler-tcp",
+    "crates/theater-handler-assembler",
     "crates/theater-replay-experimenting",
 ]
 # DEPRECATED: WASI handlers moved to crates/deprecated/
@@ -57,6 +58,7 @@ theater-handler-runtime = { version = "0.2.1", path = "crates/theater-handler-ru
 theater-handler-store = { version = "0.2.1", path = "crates/theater-handler-store" }
 theater-handler-supervisor = { version = "0.2.1", path = "crates/theater-handler-supervisor" }
 theater-handler-tcp = { version = "0.2.1", path = "crates/theater-handler-tcp" }
+theater-handler-assembler = { version = "0.2.1", path = "crates/theater-handler-assembler" }
 # DEPRECATED: WASI handlers (moved to crates/deprecated/)
 # theater-handler-environment = { version = "0.2.1", path = "crates/deprecated/theater-handler-environment" }
 # theater-handler-filesystem = { version = "0.2.1", path = "crates/deprecated/theater-handler-filesystem" }

Cargo.toml

@@ -0,0 +1,31 @@
+[package]
+name = "theater-handler-assembler"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+license.workspace = true
+repository.workspace = true
+homepage.workspace = true
+keywords.workspace = true
+categories.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+# Core theater dependencies
+theater = { path = "../theater" }
+
+# WAT to WASM conversion
+wat = "1"
+
+# Async runtime
+tokio = { version = "1.0", features = ["full"] }
+
+# Error handling
+anyhow = "1.0"
+
+# Logging
+tracing = "0.1"
+
+[dev-dependencies]
+test-log = "0.2"
+tracing-subscriber = "0.3"

crates/theater-handler-assembler/Cargo.toml

@@ -0,0 +1,159 @@
+//! # Assembler Handler
+//!
+//! Provides WAT to WASM assembly capabilities to WebAssembly actors in the Theater system.
+//! This handler allows actors to convert WebAssembly Text format (WAT) to binary WASM.
+
+use std::future::Future;
+use std::pin::Pin;
+
+use tracing::info;
+
+use theater::actor::handle::ActorHandle;
+use theater::actor::store::ActorStore;
+use theater::handler::{Handler, HandlerContext, SharedActorInstance};
+use theater::shutdown::ShutdownReceiver;
+
+// Pack integration
+use theater::pack_bridge::{Ctx, HostLinkerBuilder, LinkerError, Value, ValueType};
+
+/// Handler for providing WAT to WASM assembly capabilities
+#[derive(Clone, Default)]
+pub struct AssemblerHandler;
+
+impl AssemblerHandler {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl Handler for AssemblerHandler {
+    fn create_instance(
+        &self,
+        _config: Option<&theater::config::actor_manifest::HandlerConfig>,
+    ) -> Box<dyn Handler> {
+        Box::new(self.clone())
+    }
+
+    fn start(
+        &mut self,
+        _actor_handle: ActorHandle,
+        _actor_instance: SharedActorInstance,
+        shutdown_receiver: ShutdownReceiver,
+    ) -> Pin<Box<dyn Future<Output = anyhow::Result<()>> + Send>> {
+        info!("Starting assembler handler");
+
+        Box::pin(async {
+            // Assembler handler doesn't need a background task, just wait for shutdown
+            shutdown_receiver.wait_for_shutdown().await;
+            info!("Assembler handler received shutdown signal");
+            info!("Assembler handler shut down");
+            Ok(())
+        })
+    }
+
+    fn setup_host_functions_composite(
+        &mut self,
+        builder: &mut HostLinkerBuilder<'_, ActorStore>,
+        ctx: &mut HandlerContext,
+    ) -> Result<(), LinkerError> {
+        info!("Setting up assembler host functions (Pack)");
+
+        // Check if the interface is already satisfied by another handler
+        if ctx.is_satisfied("wisp:assembler/runtime") {
+            info!("wisp:assembler/runtime already satisfied by another handler, skipping");
+            return Ok(());
+        }
+
+        builder
+            .interface("wisp:assembler/runtime")?
+            // wat-to-wasm: func(wat: string) -> result<list<u8>, string>
+            .func_typed_result(
+                "wat-to-wasm",
+                |_ctx: &mut Ctx<'_, ActorStore>, input: Value| {
+                    let wat = match input {
+                        Value::String(s) => s,
+                        _ => {
+                            return Err(Value::String("expected string argument".to_string()));
+                        }
+                    };
+
+                    info!("[ASSEMBLER] Converting {} bytes of WAT to WASM", wat.len());
+
+                    match wat::parse_str(&wat) {
+                        Ok(wasm_bytes) => {
+                            info!("[ASSEMBLER] Success: {} bytes of WASM", wasm_bytes.len());
+                            let bytes: Vec<Value> =
+                                wasm_bytes.into_iter().map(Value::U8).collect();
+                            Ok(Value::List {
+                                elem_type: ValueType::U8,
+                                items: bytes,
+                            })
+                        }
+                        Err(e) => {
+                            info!("[ASSEMBLER] Error: {}", e);
+                            Err(Value::String(e.to_string()))
+                        }
+                    }
+                },
+            )?;
+
+        ctx.mark_satisfied("wisp:assembler/runtime");
+        Ok(())
+    }
+
+    fn supports_composite(&self) -> bool {
+        true
+    }
+
+    fn name(&self) -> &str {
+        "assembler"
+    }
+
+    fn imports(&self) -> Option<Vec<String>> {
+        Some(vec!["wisp:assembler/runtime".to_string()])
+    }
+
+    fn exports(&self) -> Option<Vec<String>> {
+        None
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_assembler_handler_creation() {
+        let handler = AssemblerHandler::new();
+        assert_eq!(handler.name(), "assembler");
+        assert_eq!(
+            handler.imports(),
+            Some(vec!["wisp:assembler/runtime".to_string()])
+        );
+        assert_eq!(handler.exports(), None);
+    }
+
+    #[test]
+    fn test_wat_to_wasm_basic() {
+        // Test that the wat crate itself works
+        let wat = "(module)";
+        let result = wat::parse_str(wat);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_wat_to_wasm_with_function() {
+        let wat = r#"
+            (module
+                (func (export "add") (param i32 i32) (result i32)
+                    local.get 0
+                    local.get 1
+                    i32.add
+                )
+            )
+        "#;
+        let result = wat::parse_str(wat);
+        assert!(result.is_ok());
+        assert!(result.unwrap().len() > 0);
+    }
+}

crates/theater-handler-assembler/src/lib.rs

@@ -0,0 +1,12 @@
+/// WIT world for the Assembler Handler
+///
+/// This world defines what the host provides to actors that import
+/// the wisp:assembler/runtime interface for converting WAT to WASM.
+
+package wisp:assembler-handler;
+
+world assembler-handler-host {
+    /// Wisp assembler interface
+    /// Provides WAT to WASM conversion functionality
+    import wisp:assembler/runtime;
+}

crates/theater-handler-assembler/wit/world.wit

@@ -413,7 +413,8 @@ impl MessageServerHandler {
                         params,
                     )
                     .await?;
-                // Result is tuple<option<list<u8>>> - extract the optional response
+                // Result is result<tuple<option<list<u8>>, tuple<option<list<u8>>>>, string>
+                // Extract the optional response
                 if let Some(response_data) = parse_option_bytes_from_tuple(&result) {
                     let _ = response_tx.send(response_data);
                 }
@@ -825,15 +826,42 @@ fn bytes_to_value(data: Vec<u8>) -> Value {
     }
 }
 
-/// Parse an option<list<u8>> from a result tuple.
-/// The result from handle-request is tuple<option<list<u8>>>.
+/// Parse an option<list<u8>> from a handle-request result.
+/// The actual return type is:
+///   result<tuple<option<list<u8>>, tuple<option<list<u8>>>>, string>
+/// We need to:
+/// 1. Unwrap the Result (if Ok)
+/// 2. Get element 1 of the outer tuple (the response tuple)
+/// 3. Get element 0 of that tuple (the option<list<u8>>)
 fn parse_option_bytes_from_tuple(value: &Value) -> Option<Vec<u8>> {
-    // Result is tuple<option<list<u8>>>
-    let inner = match value {
+    // First, unwrap the Result if present
+    let inner_tuple = match value {
+        Value::Result { value: Ok(inner), .. } => inner.as_ref(),
+        Value::Result { value: Err(_), .. } => return None,
+        // Fallback for simple tuple (backward compat)
+        Value::Tuple(_) => value,
+        _ => return None,
+    };
+
+    // Now we have tuple<option<list<u8>>, tuple<option<list<u8>>>>
+    // Element 0 is the new state, element 1 is the response tuple
+    let response_tuple = match inner_tuple {
+        Value::Tuple(items) if items.len() >= 2 => &items[1],
+        // Fallback for old format: tuple<option<list<u8>>>
+        Value::Tuple(items) if !items.is_empty() => {
+            return parse_option_bytes(&items[0]);
+        }
+        _ => return None,
+    };
+
+    // response_tuple is tuple<option<list<u8>>>
+    // Get element 0 which is the option<list<u8>>
+    let response_option = match response_tuple {
         Value::Tuple(items) if !items.is_empty() => &items[0],
         _ => return None,
     };
-    parse_option_bytes(inner)
+
+    parse_option_bytes(response_option)
 }
 
 /// Parse an option<list<u8>> Value into Option<Vec<u8>>