@temporalio/core-bridge 0.22.0 → 1.0.0-rc.1

package/src/lib.rs

@@ -1,12 +1,16 @@
 mod conversions;
 mod errors;
 
-use crate::conversions::ObjectHandleConversionsExt;
+use crate::conversions::{get_optional, ObjectHandleConversionsExt};
 use errors::*;
+use futures::stream::StreamExt;
 use neon::prelude::*;
-use once_cell::sync::OnceCell;
+use neon::types::buffer::TypedArray;
 use opentelemetry::trace::{FutureExt, SpanContext, TraceContextExt};
+use parking_lot::RwLock;
 use prost::Message;
+use std::collections::HashMap;
+use std::ops::Deref;
 use std::{
     cell::RefCell,
     fmt::Display,
@@ -20,7 +24,7 @@ use temporal_client::{
 use temporal_sdk_core::{
     api::{
         errors::{CompleteActivityError, CompleteWfError, PollActivityError, PollWfError},
-        Worker as CoreWorker,
+        Worker as CoreWorkerTrait,
     },
     fetch_global_buffered_logs, init_replay_worker, init_worker,
     protos::{
@@ -30,17 +34,18 @@ use temporal_sdk_core::{
         },
         temporal::api::history::v1::History,
     },
-    telemetry_init, ClientOptions, RetryClient, WorkerConfig,
+    telemetry_init, ClientOptions, RetryClient, Worker as CoreWorker, WorkerConfig,
 };
 use tokio::{
     runtime::Runtime,
     sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender},
 };
+use tokio_stream::wrappers::UnboundedReceiverStream;
 
 type RawClient = RetryClient<ConfiguredClient<WorkflowServiceClientWithMetrics>>;
 
 /// A request from JS to bridge to core
-enum Request {
+enum RuntimeRequest {
     /// A request to shutdown the runtime, breaks from the thread loop.
     Shutdown {
         /// Used to send the result back into JS
@@ -50,19 +55,19 @@ enum Request {
     CreateClient {
         runtime: Arc<RuntimeHandle>,
         options: ClientOptions,
+        headers: Option<HashMap<String, String>>,
         /// Used to send the result back into JS
         callback: Root<JsFunction>,
     },
-    /// A request to shutdown a worker, the worker instance will remain active to
-    /// allow draining of pending tasks
-    ShutdownWorker {
-        worker: Arc<dyn CoreWorker>,
+    /// A request to update a client's HTTP request headers
+    UpdateClientHeaders {
+        client: Arc<RawClient>,
+        headers: HashMap<String, String>,
         /// Used to send the result back into JS
         callback: Root<JsFunction>,
     },
     /// A request to create a new Worker using a connected client
     InitWorker {
-        runtime: Arc<RuntimeHandle>,
         /// Worker configuration e.g. limits and task queue
         config: WorkerConfig,
         /// A client created with a [CreateClient] request
@@ -72,7 +77,6 @@ enum Request {
     },
     /// A request to register a replay worker
     InitReplayWorker {
-        runtime: Arc<RuntimeHandle>,
         /// Worker configuration. Must have unique task queue name.
         config: WorkerConfig,
         /// The history this worker should replay
@@ -80,16 +84,29 @@ enum Request {
         /// Used to send the result back into JS
         callback: Root<JsFunction>,
     },
+    /// A request to drain logs from core so they can be emitted in node
+    PollLogs {
+        /// Logs are sent to this function
+        callback: Root<JsFunction>,
+    },
+}
+
+#[derive(Debug)]
+enum WorkerRequest {
+    /// A request to shutdown a worker, the worker instance will remain active to
+    /// allow draining of pending tasks
+    InitiateShutdown {
+        /// Used to send the result back into JS
+        callback: Root<JsFunction>,
+    },
     /// A request to poll for workflow activations
     PollWorkflowActivation {
-        worker: Arc<dyn CoreWorker>,
         otel_span: SpanContext,
         /// Used to send the result back into JS
         callback: Root<JsFunction>,
     },
     /// A request to complete a single workflow activation
     CompleteWorkflowActivation {
-        worker: Arc<dyn CoreWorker>,
         completion: WorkflowActivationCompletion,
         otel_span: SpanContext,
         /// Used to send the result back into JS
@@ -97,33 +114,23 @@ enum Request {
     },
     /// A request to poll for activity tasks
     PollActivityTask {
-        worker: Arc<dyn CoreWorker>,
         otel_span: SpanContext,
         /// Used to report completion or error back into JS
         callback: Root<JsFunction>,
     },
     /// A request to complete a single activity task
     CompleteActivityTask {
-        worker: Arc<dyn CoreWorker>,
         completion: ActivityTaskCompletion,
         otel_span: SpanContext,
         /// Used to send the result back into JS
         callback: Root<JsFunction>,
     },
     /// A request to send a heartbeat from a running activity
-    RecordActivityHeartbeat {
-        worker: Arc<dyn CoreWorker>,
-        heartbeat: ActivityHeartbeat,
-    },
-    /// A request to drain logs from core so they can be emitted in node
-    PollLogs {
-        /// Logs are sent to this function
-        callback: Root<JsFunction>,
-    },
+    RecordActivityHeartbeat { heartbeat: ActivityHeartbeat },
 }
 
 struct RuntimeHandle {
-    sender: UnboundedSender<Request>,
+    sender: UnboundedSender<RuntimeRequest>,
 }
 
 /// Box it so we can use the runtime from JS
@@ -141,34 +148,30 @@ impl Finalize for Client {}
 
 /// Worker struct, hold a reference for the channel sender responsible for sending requests from
 /// JS to a bridge thread which forwards them to core
-struct Worker {
-    runtime: Arc<RuntimeHandle>,
-    core_worker: Arc<dyn CoreWorker>,
+struct WorkerHandle {
+    sender: UnboundedSender<WorkerRequest>,
 }
 
 /// Box it so we can use Worker from JS
-type BoxedWorker = JsBox<Worker>;
-impl Finalize for Worker {}
-
-/// Lazy-inits or returns a global tokio runtime that we use for interactions with Core(s)
-fn tokio_runtime() -> &'static Runtime {
-    static INSTANCE: OnceCell<Runtime> = OnceCell::new();
-    INSTANCE.get_or_init(|| {
-        tokio::runtime::Builder::new_multi_thread()
-            .enable_all()
-            .thread_name("core")
-            .build()
-            .expect("Tokio runtime must construct properly")
-    })
+type BoxedWorker = JsBox<RefCell<Option<WorkerHandle>>>;
+impl Finalize for WorkerHandle {}
+
+/// Inits a multi-threaded tokio runtime used to interact with sdk-core APIs
+fn tokio_runtime() -> Runtime {
+    tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .thread_name("core")
+        .build()
+        .expect("Tokio runtime must construct properly")
 }
 
-/// Send a result to JS via callback using an [EventQueue]
-fn send_result<F, T>(queue: Arc<EventQueue>, callback: Root<JsFunction>, res_fn: F)
+/// Send a result to JS via callback using a [Channel]
+fn send_result<F, T>(channel: Arc<Channel>, callback: Root<JsFunction>, res_fn: F)
 where
     F: for<'a> FnOnce(&mut TaskContext<'a>) -> NeonResult<Handle<'a, T>> + Send + 'static,
     T: Value,
 {
-    queue.send(move |mut cx| {
+    channel.send(move |mut cx| {
         let callback = callback.into_inner(&mut cx);
         let this = cx.undefined();
         let error = cx.undefined();
@@ -179,13 +182,13 @@ where
     });
 }
 
-/// Send an error to JS via callback using an [EventQueue]
-fn send_error<E, F>(queue: Arc<EventQueue>, callback: Root<JsFunction>, error_ctor: F)
+/// Send an error to JS via callback using a [Channel]
+fn send_error<E, F>(channel: Arc<Channel>, callback: Root<JsFunction>, error_ctor: F)
 where
     E: Object,
     F: for<'a> FnOnce(&mut TaskContext<'a>) -> JsResult<'a, E> + Send + 'static,
 {
-    queue.send(move |mut cx| {
+    channel.send(move |mut cx| {
         let callback = callback.into_inner(&mut cx);
         callback_with_error(&mut cx, callback, error_ctor)
     });
@@ -226,33 +229,33 @@ where
     })
 }
 
-/// When Future completes, call given JS callback using a neon::EventQueue with either error or
+/// When Future completes, call given JS callback using a neon::Channel with either error or
 /// undefined
 async fn void_future_to_js<E, F, ER, EF>(
-    queue: Arc<EventQueue>,
+    channel: Arc<Channel>,
     callback: Root<JsFunction>,
     f: F,
     error_function: EF,
 ) where
     E: Display + Send + 'static,
-    F: Future<Output = Result<(), E>> + Send + 'static,
+    F: Future<Output = Result<(), E>> + Send,
     ER: Object,
     EF: for<'a> FnOnce(&mut TaskContext<'a>, E) -> JsResult<'a, ER> + Send + 'static,
 {
     match f.await {
         Ok(()) => {
-            send_result(queue, callback, |cx| Ok(cx.undefined()));
+            send_result(channel, callback, |cx| Ok(cx.undefined()));
         }
         Err(err) => {
-            send_error(queue, callback, |cx| error_function(cx, err));
+            send_error(channel, callback, |cx| error_function(cx, err));
         }
     }
 }
 
-/// Builds a tokio runtime and starts polling on [Request]s via an internal channel.
-/// Bridges requests from JS to core and sends responses back to JS using a neon::EventQueue.
+/// Builds a tokio runtime and starts polling on [RuntimeRequest]s via an internal channel.
+/// Bridges requests from JS to core and sends responses back to JS using a neon::Channel.
 /// Blocks current thread until a [Shutdown] request is received in channel.
-fn start_bridge_loop(event_queue: Arc<EventQueue>, receiver: &mut UnboundedReceiver<Request>) {
+fn start_bridge_loop(channel: Arc<Channel>, receiver: &mut UnboundedReceiver<RuntimeRequest>) {
     tokio_runtime().block_on(async {
         loop {
             let request_option = receiver.recv().await;
@@ -261,48 +264,65 @@ fn start_bridge_loop(event_queue: Arc<EventQueue>, receiver: &mut UnboundedRecei
                 Some(request) => request,
             };
 
-            let event_queue = event_queue.clone();
+            let channel = channel.clone();
 
             match request {
-                Request::Shutdown { callback } => {
-                    send_result(event_queue, callback, |cx| Ok(cx.undefined()));
+                RuntimeRequest::Shutdown { callback } => {
+                    send_result(channel, callback, |cx| Ok(cx.undefined()));
                     break;
                 }
-                Request::CreateClient {
+                RuntimeRequest::CreateClient {
                     runtime,
                     options,
+                    headers,
                     callback,
                 } => {
                     // `metrics_meter` (second arg) can be None here since we don't use the
                     // returned client directly at the moment, when we repurpose the client to be
                     // used by a Worker, `init_worker` will attach the correct metrics meter for
                     // us.
-                    match options.connect_no_namespace(None).await {
-                        Err(err) => {
-                            send_error(event_queue.clone(), callback, |cx| match err {
-                                ClientInitError::SystemInfoCallError(e) => TRANSPORT_ERROR
-                                    .from_error(cx, format!("Failed to call GetSystemInfo: {}", e)),
-                                ClientInitError::TonicTransportError(e) => {
-                                    TRANSPORT_ERROR.from_error(cx, e)
-                                }
-                                ClientInitError::InvalidUri(e) => {
-                                    Ok(JsError::type_error(cx, format!("{}", e))?.upcast())
-                                }
-                            });
-                        }
-                        Ok(client) => {
-                            send_result(event_queue.clone(), callback, |cx| {
-                                Ok(cx.boxed(RefCell::new(Some(Client {
-                                    runtime,
-                                    core_client: Arc::new(client),
-                                }))))
-                            });
+                    tokio::spawn(async move {
+                        match options
+                            .connect_no_namespace(None, headers.map(|h| Arc::new(RwLock::new(h))))
+                            .await
+                        {
+                            Err(err) => {
+                                send_error(channel.clone(), callback, |cx| match err {
+                                    ClientInitError::SystemInfoCallError(e) => TRANSPORT_ERROR
+                                        .from_string(
+                                            cx,
+                                            format!("Failed to call GetSystemInfo: {}", e),
+                                        ),
+                                    ClientInitError::TonicTransportError(e) => {
+                                        TRANSPORT_ERROR.from_error(cx, e)
+                                    }
+                                    ClientInitError::InvalidUri(e) => {
+                                        Ok(JsError::type_error(cx, format!("{}", e))?.upcast())
+                                    }
+                                });
+                            }
+                            Ok(client) => {
+                                send_result(channel.clone(), callback, |cx| {
+                                    Ok(cx.boxed(RefCell::new(Some(Client {
+                                        runtime,
+                                        core_client: Arc::new(client),
+                                    }))))
+                                });
+                            }
                         }
-                    }
+                    });
                 }
-                Request::PollLogs { callback } => {
+                RuntimeRequest::UpdateClientHeaders {
+                    client,
+                    headers,
+                    callback,
+                } => {
+                    client.get_client().set_headers(headers);
+                    send_result(channel.clone(), callback, |cx| Ok(cx.undefined()));
+                }
+                RuntimeRequest::PollLogs { callback } => {
                     let logs = fetch_global_buffered_logs();
-                    send_result(event_queue.clone(), callback, |cx| {
+                    send_result(channel.clone(), callback, |cx| {
                         let logarr = cx.empty_array();
                         for (i, cl) in logs.into_iter().enumerate() {
                             // Not much to do here except for panic when there's an
@@ -319,21 +339,7 @@ fn start_bridge_loop(event_queue: Arc<EventQueue>, receiver: &mut UnboundedRecei
                         Ok(logarr)
                     });
                 }
-                Request::ShutdownWorker { worker, callback } => {
-                    tokio::spawn(void_future_to_js(
-                        event_queue,
-                        callback,
-                        async move {
-                            worker.shutdown().await;
-                            // Wrap the empty result in a valid Result object
-                            let result: Result<(), String> = Ok(());
-                            result
-                        },
-                        |cx, err| UNEXPECTED_ERROR.from_error(cx, err),
-                    ));
-                }
-                Request::InitWorker {
-                    runtime,
+                RuntimeRequest::InitWorker {
                     config,
                     client,
                     callback,
@@ -341,134 +347,139 @@ fn start_bridge_loop(event_queue: Arc<EventQueue>, receiver: &mut UnboundedRecei
                     let client = (*client).clone();
                     let worker =
                         init_worker(config, AnyClient::LowLevel(Box::new(client.into_inner())));
-                    send_result(event_queue.clone(), callback, |cx| {
-                        Ok(cx.boxed(Worker {
-                            core_worker: Arc::new(worker),
-                            runtime,
-                        }))
+                    let (tx, rx) = unbounded_channel();
+                    tokio::spawn(start_worker_loop(worker, rx, channel.clone()));
+                    send_result(channel.clone(), callback, |cx| {
+                        Ok(cx.boxed(RefCell::new(Some(WorkerHandle { sender: tx }))))
                     });
                 }
-                Request::InitReplayWorker {
-                    runtime,
+                RuntimeRequest::InitReplayWorker {
                     config,
                     history,
                     callback,
                 } => {
                     match init_replay_worker(config, &history) {
-                        Ok(worker) => send_result(event_queue.clone(), callback, |cx| {
-                            Ok(cx.boxed(Worker {
-                                core_worker: Arc::new(worker),
-                                runtime,
-                            }))
-                        }),
-                        Err(err) => send_error(event_queue.clone(), callback, |cx| {
-                            UNEXPECTED_ERROR.from_error(cx, err)
+                        Ok(worker) => {
+                            let (tx, rx) = unbounded_channel();
+                            tokio::spawn(start_worker_loop(worker, rx, channel.clone()));
+                            send_result(channel.clone(), callback, |cx| {
+                                Ok(cx.boxed(RefCell::new(Some(WorkerHandle { sender: tx }))))
+                            })
+                        }
+                        Err(err) => send_error(channel.clone(), callback, move |cx| {
+                            UNEXPECTED_ERROR.from_error(cx, err.deref())
                         }),
                     };
                 }
-                Request::PollWorkflowActivation {
-                    worker,
-                    otel_span,
-                    callback,
-                } => {
-                    tokio::spawn(async move {
+            }
+        }
+    })
+}
+
+/// Polls on [WorkerRequest]s via given channel.
+/// Bridges requests from JS to core and sends responses back to JS using a neon::Channel.
+/// Returns when the given channel is dropped.
+async fn start_worker_loop(
+    worker: CoreWorker,
+    rx: UnboundedReceiver<WorkerRequest>,
+    channel: Arc<Channel>,
+) {
+    UnboundedReceiverStream::new(rx)
+        .for_each_concurrent(None, |request| {
+            let worker = &worker;
+            let channel = channel.clone();
+            async move {
+                match request {
+                    WorkerRequest::InitiateShutdown { callback } => {
+                        worker.initiate_shutdown();
+                        send_result(channel, callback, |cx| Ok(cx.undefined()));
+                    }
+                    WorkerRequest::PollWorkflowActivation {
+                        otel_span,
+                        callback,
+                    } => {
                         handle_poll_workflow_activation_request(
-                            &*worker,
-                            otel_span,
-                            event_queue,
-                            callback,
+                            &worker, otel_span, channel, callback,
                         )
                         .await
-                    });
-                }
-                Request::PollActivityTask {
-                    worker,
-                    otel_span,
-                    callback,
-                } => {
-                    tokio::spawn(async move {
-                        handle_poll_activity_task_request(
-                            &*worker,
-                            otel_span,
-                            event_queue,
+                    }
+                    WorkerRequest::PollActivityTask {
+                        otel_span,
+                        callback,
+                    } => {
+                        handle_poll_activity_task_request(&worker, otel_span, channel, callback)
+                            .await
+                    }
+                    WorkerRequest::CompleteWorkflowActivation {
+                        completion,
+                        otel_span,
+                        callback,
+                    } => {
+                        let otel_ctx =
+                            opentelemetry::Context::new().with_remote_span_context(otel_span);
+                        void_future_to_js(
+                            channel,
                             callback,
+                            async move {
+                                worker
+                                    .complete_workflow_activation(completion)
+                                    .with_context(otel_ctx)
+                                    .await
+                            },
+                            |cx, err| match err {
+                                CompleteWfError::TonicError(_) => {
+                                    TRANSPORT_ERROR.from_error(cx, err)
+                                }
+                                CompleteWfError::MalformedWorkflowCompletion { reason, .. } => {
+                                    Ok(JsError::type_error(cx, reason)?.upcast())
+                                }
+                            },
                         )
-                        .await
-                    });
-                }
-                Request::CompleteWorkflowActivation {
-                    worker,
-                    completion,
-                    otel_span,
-                    callback,
-                } => {
-                    let otel_ctx =
-                        opentelemetry::Context::new().with_remote_span_context(otel_span);
-                    tokio::spawn(void_future_to_js(
-                        event_queue,
-                        callback,
-                        async move {
-                            worker
-                                .complete_workflow_activation(completion)
-                                .with_context(otel_ctx)
-                                .await
-                        },
-                        |cx, err| match err {
-                            CompleteWfError::NoWorkerForQueue(queue_name) => {
-                                let args = vec![cx.string(queue_name).upcast()];
-                                NO_WORKER_ERROR.construct(cx, args)
-                            }
-                            CompleteWfError::TonicError(_) => TRANSPORT_ERROR.from_error(cx, err),
-                            CompleteWfError::MalformedWorkflowCompletion { reason, .. } => {
-                                Ok(JsError::type_error(cx, reason)?.upcast())
-                            }
-                        },
-                    ));
-                }
-                Request::CompleteActivityTask {
-                    worker,
-                    completion,
-                    otel_span,
-                    callback,
-                } => {
-                    let otel_ctx =
-                        opentelemetry::Context::new().with_remote_span_context(otel_span);
-                    tokio::spawn(void_future_to_js(
-                        event_queue,
+                        .await;
+                    }
+                    WorkerRequest::CompleteActivityTask {
+                        completion,
+                        otel_span,
                         callback,
-                        async move {
-                            worker
-                                .complete_activity_task(completion)
-                                .with_context(otel_ctx)
-                                .await
-                        },
-                        |cx, err| match err {
-                            CompleteActivityError::MalformedActivityCompletion {
-                                reason, ..
-                            } => Ok(JsError::type_error(cx, reason)?.upcast()),
-                            CompleteActivityError::TonicError(_) => {
-                                TRANSPORT_ERROR.from_error(cx, err)
-                            }
-                            CompleteActivityError::NoWorkerForQueue(queue_name) => {
-                                let args = vec![cx.string(queue_name).upcast()];
-                                NO_WORKER_ERROR.construct(cx, args)
-                            }
-                        },
-                    ));
-                }
-                Request::RecordActivityHeartbeat { worker, heartbeat } => {
-                    worker.record_activity_heartbeat(heartbeat)
+                    } => {
+                        let otel_ctx =
+                            opentelemetry::Context::new().with_remote_span_context(otel_span);
+                        void_future_to_js(
+                            channel,
+                            callback,
+                            async move {
+                                worker
+                                    .complete_activity_task(completion)
+                                    .with_context(otel_ctx)
+                                    .await
+                            },
+                            |cx, err| match err {
+                                CompleteActivityError::MalformedActivityCompletion {
+                                    reason,
+                                    ..
+                                } => Ok(JsError::type_error(cx, reason)?.upcast()),
+                                CompleteActivityError::TonicError(_) => {
+                                    TRANSPORT_ERROR.from_error(cx, err)
+                                }
+                            },
+                        )
+                        .await;
+                    }
+                    WorkerRequest::RecordActivityHeartbeat { heartbeat } => {
+                        worker.record_activity_heartbeat(heartbeat)
+                    }
                 }
             }
-        }
-    })
+        })
+        .await;
+    worker.finalize_shutdown().await;
 }
 
 /// Called within the poll loop thread, calls core and triggers JS callback with result
 async fn handle_poll_workflow_activation_request(
-    worker: &dyn CoreWorker,
+    worker: &CoreWorker,
     span_context: SpanContext,
-    event_queue: Arc<EventQueue>,
+    channel: Arc<Channel>,
     callback: Root<JsFunction>,
 ) {
     let otel_ctx = opentelemetry::Context::new().with_remote_span_context(span_context);
@@ -478,24 +489,19 @@ async fn handle_poll_workflow_activation_request(
         .await
     {
         Ok(task) => {
-            send_result(event_queue, callback, move |cx| {
+            send_result(channel, callback, move |cx| {
                 let len = task.encoded_len();
-                let mut result = JsArrayBuffer::new(cx, len as u32)?;
-                cx.borrow_mut(&mut result, |data| {
-                    let mut slice = data.as_mut_slice::<u8>();
-                    if task.encode(&mut slice).is_err() {
-                        panic!("Failed to encode task")
-                    };
-                });
+                let mut result = JsArrayBuffer::new(cx, len)?;
+                let mut slice = result.as_mut_slice(cx);
+                if task.encode(&mut slice).is_err() {
+                    panic!("Failed to encode task")
+                };
                 Ok(result)
             });
         }
         Err(err) => {
-            send_error(event_queue, callback, move |cx| match err {
+            send_error(channel, callback, move |cx| match err {
                 PollWfError::ShutDown => SHUTDOWN_ERROR.from_error(cx, err),
-                PollWfError::AutocompleteError(CompleteWfError::NoWorkerForQueue(_)) => {
-                    UNEXPECTED_ERROR.from_error(cx, "TODO this error shouldn't exist")
-                }
                 PollWfError::TonicError(_)
                 | PollWfError::AutocompleteError(CompleteWfError::TonicError(_)) => {
                     TRANSPORT_ERROR.from_error(cx, err)
@@ -511,28 +517,26 @@ async fn handle_poll_workflow_activation_request(
 
 /// Called within the poll loop thread, calls core and triggers JS callback with result
 async fn handle_poll_activity_task_request(
-    worker: &dyn CoreWorker,
+    worker: &CoreWorker,
     span_context: SpanContext,
-    event_queue: Arc<EventQueue>,
+    channel: Arc<Channel>,
     callback: Root<JsFunction>,
 ) {
     let otel_ctx = opentelemetry::Context::new().with_remote_span_context(span_context);
     match worker.poll_activity_task().with_context(otel_ctx).await {
         Ok(task) => {
-            send_result(event_queue, callback, move |cx| {
+            send_result(channel, callback, move |cx| {
                 let len = task.encoded_len();
-                let mut result = JsArrayBuffer::new(cx, len as u32)?;
-                cx.borrow_mut(&mut result, |data| {
-                    let mut slice = data.as_mut_slice::<u8>();
-                    if task.encode(&mut slice).is_err() {
-                        panic!("Failed to encode task")
-                    };
-                });
+                let mut result = JsArrayBuffer::new(cx, len)?;
+                let mut slice = result.as_mut_slice(cx);
+                if task.encode(&mut slice).is_err() {
+                    panic!("Failed to encode task")
+                };
                 Ok(result)
             });
         }
         Err(err) => {
-            send_error(event_queue, callback, move |cx| match err {
+            send_error(channel, callback, move |cx| match err {
                 PollActivityError::ShutDown => SHUTDOWN_ERROR.from_error(cx, err),
                 PollActivityError::TonicError(_) => TRANSPORT_ERROR.from_error(cx, err),
             });
@@ -554,12 +558,12 @@ fn init_telemetry(mut cx: FunctionContext) -> JsResult<JsUndefined> {
 }
 
 /// Create the tokio runtime required to run Core.
-/// Immediately spawns a poller thread that will block on [Request]s
+/// Immediately spawns a poller thread that will block on [RuntimeRequest]s
 fn runtime_new(mut cx: FunctionContext) -> JsResult<BoxedRuntime> {
-    let queue = Arc::new(cx.queue());
-    let (sender, mut receiver) = unbounded_channel::<Request>();
+    let channel = Arc::new(cx.channel());
+    let (sender, mut receiver) = unbounded_channel::<RuntimeRequest>();
 
-    std::thread::spawn(move || start_bridge_loop(queue, &mut receiver));
+    std::thread::spawn(move || start_bridge_loop(channel, &mut receiver));
 
     Ok(cx.boxed(Arc::new(RuntimeHandle { sender })))
 }
@@ -568,12 +572,28 @@ fn runtime_new(mut cx: FunctionContext) -> JsResult<BoxedRuntime> {
 /// Client will be returned in the supplied `callback`.
 fn client_new(mut cx: FunctionContext) -> JsResult<JsUndefined> {
     let runtime = cx.argument::<BoxedRuntime>(0)?;
-    let client_options = cx.argument::<JsObject>(1)?.as_client_options(&mut cx)?;
+    let opts = cx.argument::<JsObject>(1)?;
     let callback = cx.argument::<JsFunction>(2)?;
 
-    let request = Request::CreateClient {
+    let client_options = opts.as_client_options(&mut cx)?;
+    let headers = match js_optional_getter!(&mut cx, &opts, "metadata", JsObject) {
+        None => None,
+        Some(h) => Some(
+            h.as_hash_map_of_string_to_string(&mut cx)
+                .map_err(|reason| {
+                    cx.throw_type_error::<_, HashMap<String, String>>(format!(
+                        "Invalid metadata: {}",
+                        reason
+                    ))
+                    .unwrap_err()
+                })?,
+        ),
+    };
+
+    let request = RuntimeRequest::CreateClient {
         runtime: (**runtime).clone(),
         options: client_options,
+        headers,
         callback: callback.root(&mut cx),
     };
     if let Err(err) = runtime.sender.send(request) {
@@ -583,6 +603,33 @@ fn client_new(mut cx: FunctionContext) -> JsResult<JsUndefined> {
     Ok(cx.undefined())
 }
 
+/// Update a Client's HTTP request headers
+fn client_update_headers(mut cx: FunctionContext) -> JsResult<JsUndefined> {
+    let client = cx.argument::<BoxedClient>(0)?;
+    let headers = cx
+        .argument::<JsObject>(1)?
+        .as_hash_map_of_string_to_string(&mut cx)?;
+    let callback = cx.argument::<JsFunction>(2)?;
+
+    match &*client.borrow() {
+        None => {
+            callback_with_unexpected_error(&mut cx, callback, "Tried to use closed Client")?;
+        }
+        Some(client) => {
+            let request = RuntimeRequest::UpdateClientHeaders {
+                client: client.core_client.clone(),
+                headers,
+                callback: callback.root(&mut cx),
+            };
+            if let Err(err) = client.runtime.sender.send(request) {
+                callback_with_unexpected_error(&mut cx, callback, err)?;
+            };
+        }
+    }
+
+    Ok(cx.undefined())
+}
+
 /// Create a new worker asynchronously.
 /// Worker uses the provided connection and returned to JS using supplied `callback`.
 fn worker_new(mut cx: FunctionContext) -> JsResult<JsUndefined> {
@@ -593,14 +640,11 @@ fn worker_new(mut cx: FunctionContext) -> JsResult<JsUndefined> {
     let config = worker_options.as_worker_config(&mut cx)?;
     match &*client.borrow() {
         None => {
-            callback_with_error(&mut cx, callback, move |cx| {
-                UNEXPECTED_ERROR.from_string(cx, "Tried to use closed Client".to_string())
-            })?;
+            callback_with_unexpected_error(&mut cx, callback, "Tried to use closed Client")?;
         }
         Some(client) => {
-            let request = Request::InitWorker {
+            let request = RuntimeRequest::InitWorker {
                 client: client.core_client.clone(),
-                runtime: client.runtime.clone(),
                 config,
                 callback: callback.root(&mut cx),
             };
@@ -622,13 +666,10 @@ fn replay_worker_new(mut cx: FunctionContext) -> JsResult<JsUndefined> {
     let callback = cx.argument::<JsFunction>(3)?;
 
     let config = worker_options.as_worker_config(&mut cx)?;
-
-    match cx.borrow(&history_binary, |data| {
-        History::decode_length_delimited(data.as_slice::<u8>())
-    }) {
+    let data = history_binary.as_slice(&mut cx);
+    match History::decode_length_delimited(data) {
         Ok(history) => {
-            let request = Request::InitReplayWorker {
-                runtime: (**runtime).clone(),
+            let request = RuntimeRequest::InitReplayWorker {
                 config,
                 history,
                 callback: callback.root(&mut cx),
@@ -649,7 +690,7 @@ fn replay_worker_new(mut cx: FunctionContext) -> JsResult<JsUndefined> {
 fn runtime_shutdown(mut cx: FunctionContext) -> JsResult<JsUndefined> {
     let runtime = cx.argument::<BoxedRuntime>(0)?;
     let callback = cx.argument::<JsFunction>(1)?;
-    let request = Request::Shutdown {
+    let request = RuntimeRequest::Shutdown {
         callback: callback.root(&mut cx),
     };
     if let Err(err) = runtime.sender.send(request) {
@@ -662,7 +703,7 @@ fn runtime_shutdown(mut cx: FunctionContext) -> JsResult<JsUndefined> {
 fn poll_logs(mut cx: FunctionContext) -> JsResult<JsUndefined> {
     let runtime = cx.argument::<BoxedRuntime>(0)?;
     let callback = cx.argument::<JsFunction>(1)?;
-    let request = Request::PollLogs {
+    let request = RuntimeRequest::PollLogs {
         callback: callback.root(&mut cx),
     };
     if let Err(err) = runtime.sender.send(request) {
@@ -677,13 +718,19 @@ fn worker_poll_workflow_activation(mut cx: FunctionContext) -> JsResult<JsUndefi
     let worker = cx.argument::<BoxedWorker>(0)?;
     let otel_span = cx.argument::<JsObject>(1)?;
     let callback = cx.argument::<JsFunction>(2)?;
-    let request = Request::PollWorkflowActivation {
-        worker: worker.core_worker.clone(),
-        otel_span: otel_span.as_otel_span_context(&mut cx)?,
-        callback: callback.root(&mut cx),
-    };
-    if let Err(err) = worker.runtime.sender.send(request) {
-        callback_with_unexpected_error(&mut cx, callback, err)?;
+    match &*worker.borrow() {
+        None => {
+            callback_with_unexpected_error(&mut cx, callback, "Tried to use closed Worker")?;
+        }
+        Some(worker) => {
+            let request = WorkerRequest::PollWorkflowActivation {
+                otel_span: otel_span.as_otel_span_context(&mut cx)?,
+                callback: callback.root(&mut cx),
+            };
+            if let Err(err) = worker.sender.send(request) {
+                callback_with_unexpected_error(&mut cx, callback, err)?;
+            }
+        }
     }
     Ok(cx.undefined())
 }
@@ -694,13 +741,19 @@ fn worker_poll_activity_task(mut cx: FunctionContext) -> JsResult<JsUndefined> {
     let worker = cx.argument::<BoxedWorker>(0)?;
     let otel_span = cx.argument::<JsObject>(1)?;
     let callback = cx.argument::<JsFunction>(2)?;
-    let request = Request::PollActivityTask {
-        worker: worker.core_worker.clone(),
-        otel_span: otel_span.as_otel_span_context(&mut cx)?,
-        callback: callback.root(&mut cx),
-    };
-    if let Err(err) = worker.runtime.sender.send(request) {
-        callback_with_unexpected_error(&mut cx, callback, err)?;
+    match &*worker.borrow() {
+        None => {
+            callback_with_unexpected_error(&mut cx, callback, "Tried to use closed Worker")?;
+        }
+        Some(worker) => {
+            let request = WorkerRequest::PollActivityTask {
+                otel_span: otel_span.as_otel_span_context(&mut cx)?,
+                callback: callback.root(&mut cx),
+            };
+            if let Err(err) = worker.sender.send(request) {
+                callback_with_unexpected_error(&mut cx, callback, err)?;
+            }
+        }
     }
     Ok(cx.undefined())
 }
@@ -711,24 +764,29 @@ fn worker_complete_workflow_activation(mut cx: FunctionContext) -> JsResult<JsUn
     let otel_span = cx.argument::<JsObject>(1)?;
     let completion = cx.argument::<JsArrayBuffer>(2)?;
     let callback = cx.argument::<JsFunction>(3)?;
-    let result = cx.borrow(&completion, |data| {
-        WorkflowActivationCompletion::decode_length_delimited(data.as_slice::<u8>())
-    });
-    match result {
-        Ok(completion) => {
-            let request = Request::CompleteWorkflowActivation {
-                worker: worker.core_worker.clone(),
-                completion,
-                otel_span: otel_span.as_otel_span_context(&mut cx)?,
-                callback: callback.root(&mut cx),
-            };
-            if let Err(err) = worker.runtime.sender.send(request) {
-                callback_with_unexpected_error(&mut cx, callback, err)?;
-            };
+    match &*worker.borrow() {
+        None => {
+            callback_with_unexpected_error(&mut cx, callback, "Tried to use closed Worker")?;
+        }
+        Some(worker) => {
+            match WorkflowActivationCompletion::decode_length_delimited(
+                completion.as_slice(&mut cx),
+            ) {
+                Ok(completion) => {
+                    let request = WorkerRequest::CompleteWorkflowActivation {
+                        completion,
+                        otel_span: otel_span.as_otel_span_context(&mut cx)?,
+                        callback: callback.root(&mut cx),
+                    };
+                    if let Err(err) = worker.sender.send(request) {
+                        callback_with_unexpected_error(&mut cx, callback, err)?;
+                    };
+                }
+                Err(_) => callback_with_error(&mut cx, callback, |cx| {
+                    JsError::type_error(cx, "Cannot decode Completion from buffer")
+                })?,
+            }
         }
-        Err(_) => callback_with_error(&mut cx, callback, |cx| {
-            JsError::type_error(cx, "Cannot decode Completion from buffer")
-        })?,
     };
     Ok(cx.undefined())
 }
@@ -739,24 +797,27 @@ fn worker_complete_activity_task(mut cx: FunctionContext) -> JsResult<JsUndefine
     let otel_span = cx.argument::<JsObject>(1)?;
     let result = cx.argument::<JsArrayBuffer>(2)?;
     let callback = cx.argument::<JsFunction>(3)?;
-    let result = cx.borrow(&result, |data| {
-        ActivityTaskCompletion::decode_length_delimited(data.as_slice::<u8>())
-    });
-    match result {
-        Ok(completion) => {
-            let request = Request::CompleteActivityTask {
-                worker: worker.core_worker.clone(),
-                completion,
-                otel_span: otel_span.as_otel_span_context(&mut cx)?,
-                callback: callback.root(&mut cx),
-            };
-            if let Err(err) = worker.runtime.sender.send(request) {
-                callback_with_unexpected_error(&mut cx, callback, err)?;
-            };
+    match &*worker.borrow() {
+        None => {
+            callback_with_unexpected_error(&mut cx, callback, "Tried to use closed Worker")?;
+        }
+        Some(worker) => {
+            match ActivityTaskCompletion::decode_length_delimited(result.as_slice(&mut cx)) {
+                Ok(completion) => {
+                    let request = WorkerRequest::CompleteActivityTask {
+                        completion,
+                        otel_span: otel_span.as_otel_span_context(&mut cx)?,
+                        callback: callback.root(&mut cx),
+                    };
+                    if let Err(err) = worker.sender.send(request) {
+                        callback_with_unexpected_error(&mut cx, callback, err)?;
+                    };
+                }
+                Err(_) => callback_with_error(&mut cx, callback, |cx| {
+                    JsError::type_error(cx, "Cannot decode Completion from buffer")
+                })?,
+            }
         }
-        Err(_) => callback_with_error(&mut cx, callback, |cx| {
-            JsError::type_error(cx, "Cannot decode Completion from buffer")
-        })?,
     };
     Ok(cx.undefined())
 }
@@ -765,41 +826,59 @@ fn worker_complete_activity_task(mut cx: FunctionContext) -> JsResult<JsUndefine
 fn worker_record_activity_heartbeat(mut cx: FunctionContext) -> JsResult<JsUndefined> {
     let worker = cx.argument::<BoxedWorker>(0)?;
     let heartbeat = cx.argument::<JsArrayBuffer>(1)?;
-    let heartbeat = cx.borrow(&heartbeat, |data| {
-        ActivityHeartbeat::decode_length_delimited(data.as_slice::<u8>())
-    });
-    match heartbeat {
-        Ok(heartbeat) => {
-            let request = Request::RecordActivityHeartbeat {
-                worker: worker.core_worker.clone(),
-                heartbeat,
-            };
-            match worker.runtime.sender.send(request) {
-                Err(err) => UNEXPECTED_ERROR
-                    .from_error(&mut cx, err)
-                    .and_then(|err| cx.throw(err)),
-                _ => Ok(cx.undefined()),
+    match &*worker.borrow() {
+        None => UNEXPECTED_ERROR
+            .from_string(&mut cx, "Tried to use closed Worker")
+            .and_then(|err| cx.throw(err))?,
+        Some(worker) => {
+            match ActivityHeartbeat::decode_length_delimited(heartbeat.as_slice(&mut cx)) {
+                Ok(heartbeat) => {
+                    let request = WorkerRequest::RecordActivityHeartbeat { heartbeat };
+                    if let Err(err) = worker.sender.send(request) {
+                        UNEXPECTED_ERROR
+                            .from_error(&mut cx, err)
+                            .and_then(|err| cx.throw(err))?;
+                    }
+                }
+                Err(_) => cx.throw_type_error("Cannot decode ActivityHeartbeat from buffer")?,
             }
         }
-        Err(_) => cx.throw_type_error("Cannot decode ActivityHeartbeat from buffer"),
-    }
+    };
+    Ok(cx.undefined())
 }
 
 /// Request shutdown of the worker.
 /// Once complete Core will stop polling on new tasks and activations on worker's task queue.
-/// Caller should drain any pending tasks and activations before breaking from
+/// Caller should drain any pending tasks and activations and call worker_finalize_shutdown before breaking from
 /// the loop to ensure graceful shutdown.
-fn worker_shutdown(mut cx: FunctionContext) -> JsResult<JsUndefined> {
+fn worker_initiate_shutdown(mut cx: FunctionContext) -> JsResult<JsUndefined> {
     let worker = cx.argument::<BoxedWorker>(0)?;
     let callback = cx.argument::<JsFunction>(1)?;
-    if let Err(err) = worker.runtime.sender.send(Request::ShutdownWorker {
-        worker: worker.core_worker.clone(),
-        callback: callback.root(&mut cx),
-    }) {
-        UNEXPECTED_ERROR
-            .from_error(&mut cx, err)
+    match &*worker.borrow() {
+        None => {
+            callback_with_unexpected_error(&mut cx, callback, "Tried to use closed Worker")?;
+        }
+        Some(worker) => {
+            if let Err(err) = worker.sender.send(WorkerRequest::InitiateShutdown {
+                callback: callback.root(&mut cx),
+            }) {
+                UNEXPECTED_ERROR
+                    .from_error(&mut cx, err)
+                    .and_then(|err| cx.throw(err))?;
+            };
+        }
+    }
+    Ok(cx.undefined())
+}
+
+fn worker_finalize_shutdown(mut cx: FunctionContext) -> JsResult<JsUndefined> {
+    let worker = cx.argument::<BoxedWorker>(0)?;
+    if worker.replace(None).is_none() {
+        ILLEGAL_STATE_ERROR
+            .from_string(&mut cx, "Worker already closed")
             .and_then(|err| cx.throw(err))?;
-    };
+    }
+
     Ok(cx.undefined())
 }
 
@@ -808,7 +887,7 @@ fn client_close(mut cx: FunctionContext) -> JsResult<JsUndefined> {
     let client = cx.argument::<BoxedClient>(0)?;
     if client.replace(None).is_none() {
         ILLEGAL_STATE_ERROR
-            .from_error(&mut cx, "Client already closed")
+            .from_string(&mut cx, "Client already closed")
             .and_then(|err| cx.throw(err))?;
     };
     Ok(cx.undefined())
@@ -843,9 +922,11 @@ fn main(mut cx: ModuleContext) -> NeonResult<()> {
     cx.export_function("initTelemetry", init_telemetry)?;
     cx.export_function("newRuntime", runtime_new)?;
     cx.export_function("newClient", client_new)?;
+    cx.export_function("clientUpdateHeaders", client_update_headers)?;
     cx.export_function("newWorker", worker_new)?;
     cx.export_function("newReplayWorker", replay_worker_new)?;
-    cx.export_function("workerShutdown", worker_shutdown)?;
+    cx.export_function("workerInitiateShutdown", worker_initiate_shutdown)?;
+    cx.export_function("workerFinalizeShutdown", worker_finalize_shutdown)?;
     cx.export_function("clientClose", client_close)?;
     cx.export_function("runtimeShutdown", runtime_shutdown)?;
     cx.export_function("pollLogs", poll_logs)?;