Drop Send/Sync from Actor + ActorBehavior + ActorState on wasm32

The actor framework required `Send + Sync` everywhere because the
native runtime drives actors on tokio's multi-threaded executor.
On `wasm32-unknown-unknown` the runtime is single-threaded
(`spawn_local`) and the bound is gratuitous — but it was rejecting
every browser-only type that holds raw JS handles (`*mut u8`):
  - `wgpu::backend::webgpu::WebQueue/WebTexture/WebBuffer`
  - `reqwest::wasm::AbortGuard`
  - `web_sys::WebSocket`, `web_sys::GpuDevice`, …

Fixes:

- Introduce `MaybeSend` / `MaybeSync` marker traits. Both collapse
  to `Send` / `Sync` on native and to nothing on wasm32. Use these
  for trait supertraits (`Actor`, `ActorState`).
- For `dyn Future + Send` trait objects, marker traits don't help
  (Rust forbids combining a custom trait with a non-auto trait in
  a dyn). Cfg-split `ActorBehavior`, `Actor::create_process`,
  `ActorProcess::into_future`, and `Network::init_process` to drop
  `+ Send` on wasm.
- Tidy reflow_components: gate `crate::io::FileLoadActor/FileSaveActor`
  imports + registry entries to native (already done at the module
  level, but the registry imports were unconditional). Document gpu
  module as "feature-gated wgpu pieces are native-only — sdf path
  utilities and font atlas math stay available to wasm consumers".

Result: `cargo check --target wasm32-unknown-unknown -p reflow_components`
is clean. The wgpu/openh264/chromiumoxide-feature actors remain
native-only — those need separate work for the wgpu+wasm async init
story (no `pollster::block_on` in browser).

Author: darmie

crates/reflow_actor/src/lib.rs

@@ -29,7 +29,52 @@ use crate::{
     types::GraphNode,
 };
 
-// #[cfg(not(target_arch = "wasm32"))]
+/// Cross-target `Send`/`Sync` markers.
+///
+/// On native, `MaybeSend` ≡ `Send`, `MaybeSync` ≡ `Sync` — the actor
+/// runtime uses tokio's multi-threaded executor and needs both.
+///
+/// On `wasm32-unknown-unknown` the executor is single-threaded
+/// (`spawn_local`), so we drop both bounds. That unblocks browser-only
+/// types that hold raw JS handles (`*mut u8`) under the hood —
+/// `wgpu::WebQueue`, `reqwest`'s `AbortGuard`, `web_sys::WebSocket`,
+/// `web_sys::GpuDevice`, … — none of which can satisfy `Send`.
+///
+/// This is the same pattern tokio, gloo, and async-std use.
+#[cfg(not(target_arch = "wasm32"))]
+pub trait MaybeSend: Send {}
+#[cfg(not(target_arch = "wasm32"))]
+impl<T: Send + ?Sized> MaybeSend for T {}
+
+#[cfg(target_arch = "wasm32")]
+pub trait MaybeSend {}
+#[cfg(target_arch = "wasm32")]
+impl<T: ?Sized> MaybeSend for T {}
+
+#[cfg(not(target_arch = "wasm32"))]
+pub trait MaybeSync: Sync {}
+#[cfg(not(target_arch = "wasm32"))]
+impl<T: Sync + ?Sized> MaybeSync for T {}
+
+#[cfg(target_arch = "wasm32")]
+pub trait MaybeSync {}
+#[cfg(target_arch = "wasm32")]
+impl<T: ?Sized> MaybeSync for T {}
+
+/// Type-erased actor body. The closure produces a future that resolves
+/// to the actor's port outputs.
+///
+/// On native, the future + closure are `Send + Sync` so the network can
+/// drive them via tokio's multi-threaded executor. On
+/// `wasm32-unknown-unknown` the executor is single-threaded
+/// (`spawn_local`), so we drop the auto-trait bounds — that unblocks
+/// browser-only types (`wgpu::WebQueue`, `reqwest::AbortGuard`,
+/// `web_sys::WebSocket`, …) which hold raw JS handles and are `!Send`.
+///
+/// Two cfg-split type aliases is the only way: trait objects can't
+/// combine a custom marker trait with a non-auto trait like `Future`,
+/// so a `MaybeSend` shim doesn't apply to `dyn Future + Send`.
+#[cfg(not(target_arch = "wasm32"))]
 pub type ActorBehavior = Box<
     dyn Fn(
             ActorContext,
@@ -44,6 +89,18 @@ pub type ActorBehavior = Box<
         + 'static,
 >;
 
+#[cfg(target_arch = "wasm32")]
+pub type ActorBehavior = Box<
+    dyn Fn(
+            ActorContext,
+        ) -> std::pin::Pin<
+            Box<
+                dyn std::future::Future<Output = Result<HashMap<String, Message>, anyhow::Error>>
+                    + 'static,
+            >,
+        > + 'static,
+>;
+
 pub type ActorPayload = HashMap<String, Message>;
 pub type ActorChannel = (
     flume::Sender<crate::message::Message>,
@@ -223,8 +280,10 @@ impl ActorConfig {
     }
 }
 
-// #[cfg(not(target_arch = "wasm32"))]
-pub trait Actor: Send + Sync + 'static {
+// `MaybeSend` + `MaybeSync` collapse to `Send + Sync` on native and to
+// nothing on wasm32. See the marker definitions near the top of this
+// module.
+pub trait Actor: MaybeSend + MaybeSync + 'static {
     /// The actor's reaction to incoming data. This is the only thing an actor
     /// *must* define beyond port declarations.
     fn get_behavior(&self) -> ActorBehavior;
@@ -302,6 +361,7 @@ pub trait Actor: Send + Sync + 'static {
     ///
     /// Override only when you need a fundamentally different execution
     /// model (e.g. SubgraphActor's inner-network routing).
+    #[cfg(not(target_arch = "wasm32"))]
     fn create_process(
         &self,
         config: ActorConfig,
@@ -323,6 +383,28 @@ pub trait Actor: Send + Sync + 'static {
         .into_future()
     }
 
+    #[cfg(target_arch = "wasm32")]
+    fn create_process(
+        &self,
+        config: ActorConfig,
+        tracing_integration: Option<TracingIntegration>,
+    ) -> std::pin::Pin<Box<dyn futures::Future<Output = ()> + 'static>> {
+        crate::process::ActorProcess::new(
+            config.get_node_id().to_string(),
+            self.get_behavior(),
+            self.inport_names(),
+            self.await_all_inports(),
+            self.required_inports(),
+            self.get_inports().1,
+            self.get_outports(),
+            self.create_state(),
+            self.load_count(),
+            config,
+            tracing_integration,
+        )
+        .into_future()
+    }
+
     /// Shutdown the actor, waiting for all processes to finish
     fn shutdown(&self) {
         while self.load_count().get() > 0 {
@@ -734,7 +816,7 @@ impl BrowserActorContext {
     }
 }
 
-pub trait ActorState: Send + Sync + 'static {
+pub trait ActorState: MaybeSend + MaybeSync + 'static {
     fn as_any(&self) -> &dyn Any;
     fn as_mut_any(&mut self) -> &mut dyn Any;
 }
@@ -1321,7 +1403,7 @@ impl Actor for JsBrowserActor {
         &self,
         config: ActorConfig,
         tracing_integration: Option<TracingIntegration>,
-    ) -> std::pin::Pin<Box<dyn futures::Future<Output = ()> + 'static + Send>> {
+    ) -> std::pin::Pin<Box<dyn futures::Future<Output = ()> + 'static>> {
         self.actor.create_process(config, tracing_integration)
     }
 }
@@ -1446,7 +1528,7 @@ impl Actor for BrowserActor {
         &self,
         actor_config: ActorConfig,
         _tracing_integration: Option<TracingIntegration>,
-    ) -> std::pin::Pin<Box<dyn futures::Future<Output = ()> + 'static + Send>> {
+    ) -> std::pin::Pin<Box<dyn futures::Future<Output = ()> + 'static>> {
         use futures::StreamExt;
         use serde_json::json;
 

crates/reflow_actor/src/process.rs

@@ -179,11 +179,21 @@ impl ActorProcess {
 
     /// Consume self and return a boxed, pinned future suitable for
     /// `tokio::spawn` or the Actor trait's `create_process` return type.
+    #[cfg(not(target_arch = "wasm32"))]
     pub fn into_future(
         self,
     ) -> std::pin::Pin<Box<dyn std::future::Future<Output = ()> + Send + 'static>> {
         Box::pin(self.run())
     }
+
+    /// wasm32 variant — no `Send` because the runtime is single-threaded
+    /// (`spawn_local`) and browser-only types are typically `!Send`.
+    #[cfg(target_arch = "wasm32")]
+    pub fn into_future(
+        self,
+    ) -> std::pin::Pin<Box<dyn std::future::Future<Output = ()> + 'static>> {
+        Box::pin(self.run())
+    }
 }
 
 /// Merge-aware accumulation for fan-in synchronization.

crates/reflow_components/src/lib.rs

@@ -47,6 +47,12 @@ pub use reflow_api_services::api;
 pub mod assets;
 mod display;
 pub mod flow_control;
+// `gpu/` exposes both pure-Rust modules (path/sdf-IR consumers,
+// font atlas math) and wgpu-backed renderers. Wasm-incompatible
+// pieces are gated inside `gpu/mod.rs` behind `feature = "gpu"`,
+// which is native-only — see Cargo.toml. The browser-friendly
+// subset (sdf path utilities, font atlas data) stays available so
+// `procedural::tube_mesh` and friends still link.
 pub mod gpu;
 #[cfg(feature = "window-events")]
 pub mod input;

crates/reflow_components/src/registry.rs

@@ -59,10 +59,12 @@ use crate::input::{
 use crate::integration::BrowserScreencastActor;
 use crate::integration::HttpRequestActor;
 use crate::io::{
-    FbxImportActor, FileLoadActor, FileSaveActor, GltfExportActor, GltfImportActor,
-    MeshImportActor, ObjExportActor, ObjImportActor, SceneImportActor, StlExportActor,
-    StlImportActor,
+    FbxImportActor, GltfExportActor, GltfImportActor, MeshImportActor, ObjExportActor,
+    ObjImportActor, SceneImportActor, StlExportActor, StlImportActor,
 };
+// File load/save actors are native-only (require tokio::fs).
+#[cfg(not(target_arch = "wasm32"))]
+use crate::io::{FileLoadActor, FileSaveActor};
 use crate::logic::RulesEngineActor;
 use crate::math::{
     Mat4IdentityActor,
@@ -321,8 +323,10 @@ pub fn get_actor_for_template(template_id: &str) -> Option<Arc<dyn Actor>> {
         "tpl_image_decode" => Some(Arc::new(ImageDecodeActor::new())),
         "tpl_image_encode" => Some(Arc::new(ImageEncodeActor::new())),
 
-        // File I/O
+        // File I/O — native-only (no filesystem in browser).
+        #[cfg(not(target_arch = "wasm32"))]
         "tpl_file_load" => Some(Arc::new(FileLoadActor::new())),
+        #[cfg(not(target_arch = "wasm32"))]
         "tpl_file_save" => Some(Arc::new(FileSaveActor::new())),
 
         // Stream Display

crates/reflow_network/src/network.rs

@@ -660,7 +660,7 @@ impl Network {
     }
     #[cfg(target_arch = "wasm32")]
     pub(crate) fn init_process(
-        actor_process: std::pin::Pin<Box<dyn futures::Future<Output = ()> + 'static + Send>>,
+        actor_process: std::pin::Pin<Box<dyn futures::Future<Output = ()> + 'static>>,
     ) {
         spawn_local(actor_process);
     }