@temporalio/core-bridge 0.19.2 → 0.20.2

package/src/lib.rs

@@ -10,18 +10,18 @@ use prost::Message;
 use std::{
     fmt::Display,
     future::Future,
-    ops::Deref,
     sync::Arc,
     time::{Duration, SystemTime, UNIX_EPOCH},
 };
+use temporal_client::{
+    AnyClient, ClientInitError, ConfiguredClient, WorkflowServiceClientWithMetrics,
+};
 use temporal_sdk_core::{
     api::{
-        errors::{
-            CompleteActivityError, CompleteWfError, CoreInitError, PollActivityError, PollWfError,
-        },
-        Core,
+        errors::{CompleteActivityError, CompleteWfError, PollActivityError, PollWfError},
+        Worker as CoreWorker,
     },
-    init,
+    fetch_global_buffered_logs, init_replay_worker, init_worker,
     protos::{
         coresdk::{
             workflow_completion::WorkflowActivationCompletion, ActivityHeartbeat,
@@ -29,39 +29,49 @@ use temporal_sdk_core::{
         },
         temporal::api::history::v1::History,
     },
-    replay::{init_core_replay, ReplayCore, ReplayCoreImpl},
-    CoreInitOptionsBuilder, CoreSDK, WorkerConfig,
+    telemetry_init, ClientOptions, RetryClient, WorkerConfig,
 };
 use tokio::{
     runtime::Runtime,
-    sync::mpsc::{unbounded_channel, UnboundedSender},
+    sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender},
 };
 
+type RawClient = RetryClient<ConfiguredClient<WorkflowServiceClientWithMetrics>>;
+
 /// A request from JS to bridge to core
-#[derive(Debug)]
 enum Request {
-    /// A request to shutdown Core, any registered workers will be shutdown as well.
-    /// Breaks from the thread loop.
+    /// A request to shutdown the runtime, breaks from the thread loop.
     Shutdown {
         /// Used to send the result back into JS
         callback: Root<JsFunction>,
     },
+    /// A request to create a client in a runtime
+    CreateClient {
+        runtime: Arc<RuntimeHandle>,
+        options: ClientOptions,
+        /// 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 {
-        task_queue: String,
+        worker: Arc<dyn CoreWorker>,
         /// Used to send the result back into JS
         callback: Root<JsFunction>,
     },
-    /// A request to register a new Worker against Core
-    RegisterWorker {
+    /// 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
+        client: Arc<RawClient>,
         /// Used to send the result back into JS
         callback: Root<JsFunction>,
     },
-    /// A request to register a replay worker. Will only work against a replay core instance.
-    RegisterReplayWorker {
+    /// 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
@@ -71,14 +81,14 @@ enum Request {
     },
     /// A request to poll for workflow activations
     PollWorkflowActivation {
-        /// Name of queue to poll on
-        queue_name: String,
+        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
@@ -86,21 +96,24 @@ enum Request {
     },
     /// A request to poll for activity tasks
     PollActivityTask {
-        /// Name of queue to poll on
-        queue_name: String,
+        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 { heartbeat: ActivityHeartbeat },
+    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
@@ -108,40 +121,34 @@ enum Request {
     },
 }
 
-#[derive(Clone)]
-struct CoreHandle {
+struct RuntimeHandle {
     sender: UnboundedSender<Request>,
 }
-/// Box it so we can use Core from JS
-type BoxedCore = JsBox<CoreHandle>;
-impl Finalize for CoreHandle {}
+
+/// Box it so we can use the runtime from JS
+type BoxedRuntime = JsBox<Arc<RuntimeHandle>>;
+impl Finalize for RuntimeHandle {}
+
+#[derive(Clone)]
+struct Client {
+    runtime: Arc<RuntimeHandle>,
+    core_client: Arc<RawClient>,
+}
+
+type BoxedClient = JsBox<Client>;
+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 {
-    core: CoreHandle,
-    queue: String,
+    runtime: Arc<RuntimeHandle>,
+    core_worker: Arc<dyn CoreWorker>,
 }
+
 /// Box it so we can use Worker from JS
 type BoxedWorker = JsBox<Worker>;
 impl Finalize for Worker {}
 
-enum CoreType {
-    Real(CoreSDK),
-    Replay(ReplayCoreImpl),
-}
-
-impl Deref for CoreType {
-    type Target = dyn Core;
-
-    fn deref(&self) -> &Self::Target {
-        match self {
-            CoreType::Real(ref r) => r,
-            CoreType::Replay(ref r) => r,
-        }
-    }
-}
-
 /// 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();
@@ -183,7 +190,7 @@ where
     });
 }
 
-/// Call [callback] with given error
+/// Call `callback` with given error
 fn callback_with_error<'a, C, E, F>(
     cx: &mut C,
     callback: Handle<JsFunction>,
@@ -202,6 +209,7 @@ where
     Ok(())
 }
 
+/// Call `callback` with an UnexpectedError created from `err`
 fn callback_with_unexpected_error<'a, C, E>(
     cx: &mut C,
     callback: Handle<JsFunction>,
@@ -242,234 +250,213 @@ async fn void_future_to_js<E, F, ER, EF>(
 
 /// 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.
-/// Blocks current thread until a [BreakPoller] request is received in channel.
-fn start_bridge_loop(
-    core_init_fut: impl Future<Output = Result<CoreType, CoreInitError>>,
-    event_queue: Arc<EventQueue>,
-    callback: Root<JsFunction>,
-) {
-    let (sender, mut receiver) = unbounded_channel::<Request>();
-
+/// Blocks current thread until a [Shutdown] request is received in channel.
+fn start_bridge_loop(event_queue: Arc<EventQueue>, receiver: &mut UnboundedReceiver<Request>) {
     tokio_runtime().block_on(async {
-        match core_init_fut.await {
-            Err(err) => {
-                send_error(event_queue.clone(), callback, |cx| match err {
-                    CoreInitError::GatewayInitError(err) => TRANSPORT_ERROR.from_error(cx, err),
-                    e @ CoreInitError::TelemetryInitError(_) => UNEXPECTED_ERROR.from_error(cx, e),
-                });
-            }
-            Ok(result) => {
-                let core = Arc::new(result);
-                let core_handle = CoreHandle { sender };
-                // Clone once to send back to JS via event queue
-                let cloned_core_handle = core_handle.clone();
-                send_result(event_queue.clone(), callback, |cx| {
-                    Ok(cx.boxed(cloned_core_handle))
-                });
+        loop {
+            let request_option = receiver.recv().await;
+            let request = match request_option {
+                None => break,
+                Some(request) => request,
+            };
 
-                loop {
-                    let request_option = receiver.recv().await;
-                    let request = match request_option {
-                        None => break,
-                        Some(request) => request,
-                    };
+            let event_queue = event_queue.clone();
 
-                    let core = core.clone();
-                    let event_queue = event_queue.clone();
-
-                    match request {
-                        Request::Shutdown { callback } => {
-                            void_future_to_js(
-                                event_queue,
-                                callback,
-                                async move {
-                                    core.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),
-                            )
-                            .await;
-                            break;
-                        }
-                        Request::PollLogs { callback } => {
-                            let logs = core.fetch_buffered_logs();
-                            send_result(event_queue.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
-                                    // error here.
-                                    let logobj = cx.empty_object();
-                                    let level = cx.string(cl.level.to_string());
-                                    logobj.set(cx, "level", level).unwrap();
-                                    let ts = system_time_to_js(cx, cl.timestamp).unwrap();
-                                    logobj.set(cx, "timestamp", ts).unwrap();
-                                    let msg = cx.string(cl.message);
-                                    logobj.set(cx, "message", msg).unwrap();
-                                    logarr.set(cx, i as u32, logobj).unwrap();
+            match request {
+                Request::Shutdown { callback } => {
+                    send_result(event_queue, callback, |cx| Ok(cx.undefined()));
+                    break;
+                }
+                Request::CreateClient {
+                    runtime,
+                    options,
+                    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(logarr)
                             });
                         }
-                        Request::ShutdownWorker {
-                            task_queue,
-                            callback,
-                        } => {
-                            tokio::spawn(void_future_to_js(
-                                event_queue,
-                                callback,
-                                async move {
-                                    core.shutdown_worker(&task_queue).await;
-                                    // Wrap the empty result in a valid Result object
-                                    let result: Result<(), String> = Ok(());
-                                    result
-                                },
-                                |cx, err| UNEXPECTED_ERROR.from_error(cx, err),
-                            ));
+                        Ok(client) => {
+                            send_result(event_queue.clone(), callback, |cx| {
+                                Ok(cx.boxed(Client {
+                                    runtime,
+                                    core_client: Arc::new(client),
+                                }))
+                            });
                         }
-                        Request::RegisterWorker { config, callback } => {
-                            let task_queue = config.task_queue.clone();
-                            match core.register_worker(config) {
-                                Ok(_) => {
-                                    let core_handle = core_handle.clone();
-                                    send_result(event_queue.clone(), callback, |cx| {
-                                        Ok(cx.boxed(Worker {
-                                            core: core_handle,
-                                            queue: task_queue,
-                                        }))
-                                    })
-                                }
-                                Err(err) => send_error(event_queue.clone(), callback, |cx| {
-                                    UNEXPECTED_ERROR.from_error(cx, err)
-                                }),
-                            };
+                    }
+                }
+                Request::PollLogs { callback } => {
+                    let logs = fetch_global_buffered_logs();
+                    send_result(event_queue.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
+                            // error here.
+                            let logobj = cx.empty_object();
+                            let level = cx.string(cl.level.to_string());
+                            logobj.set(cx, "level", level).unwrap();
+                            let ts = system_time_to_js(cx, cl.timestamp).unwrap();
+                            logobj.set(cx, "timestamp", ts).unwrap();
+                            let msg = cx.string(cl.message);
+                            logobj.set(cx, "message", msg).unwrap();
+                            logarr.set(cx, i as u32, logobj).unwrap();
                         }
-                        Request::RegisterReplayWorker {
-                            config,
-                            history,
-                            callback,
-                        } => match *core {
-                            CoreType::Real(_) => {
-                                panic!(
-                                    "Attempted to use a real core instance to register a \
-                                        replay worker. This is a bug in the TS SDK."
-                                )
-                            }
-                            CoreType::Replay(ref rc) => {
-                                let task_queue = config.task_queue.clone();
-                                match rc.make_replay_worker(config, &history) {
-                                    Ok(_) => {
-                                        let core_handle = core_handle.clone();
-                                        send_result(event_queue.clone(), callback, |cx| {
-                                            Ok(cx.boxed(Worker {
-                                                core: core_handle,
-                                                queue: task_queue,
-                                            }))
-                                        })
-                                    }
-                                    Err(err) => send_error(event_queue.clone(), callback, |cx| {
-                                        UNEXPECTED_ERROR.from_error(cx, err)
-                                    }),
-                                };
-                            }
+                        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
                         },
-                        Request::PollWorkflowActivation {
-                            queue_name,
+                        |cx, err| UNEXPECTED_ERROR.from_error(cx, err),
+                    ));
+                }
+                Request::InitWorker {
+                    runtime,
+                    config,
+                    client,
+                    callback,
+                } => {
+                    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,
+                        }))
+                    });
+                }
+                Request::InitReplayWorker {
+                    runtime,
+                    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)
+                        }),
+                    };
+                }
+                Request::PollWorkflowActivation {
+                    worker,
+                    otel_span,
+                    callback,
+                } => {
+                    tokio::spawn(async move {
+                        handle_poll_workflow_activation_request(
+                            &*worker,
                             otel_span,
+                            event_queue,
                             callback,
-                        } => {
-                            // dbg!(&queue_name);
-                            tokio::spawn(async move {
-                                handle_poll_workflow_activation_request(
-                                    queue_name,
-                                    otel_span,
-                                    core.as_ref().deref(),
-                                    event_queue,
-                                    callback,
-                                )
-                                .await
-                            });
-                        }
-                        Request::PollActivityTask {
-                            queue_name,
+                        )
+                        .await
+                    });
+                }
+                Request::PollActivityTask {
+                    worker,
+                    otel_span,
+                    callback,
+                } => {
+                    tokio::spawn(async move {
+                        handle_poll_activity_task_request(
+                            &*worker,
                             otel_span,
+                            event_queue,
                             callback,
-                        } => {
-                            tokio::spawn(async move {
-                                handle_poll_activity_task_request(
-                                    queue_name,
-                                    otel_span,
-                                    core.as_ref().deref(),
-                                    event_queue,
-                                    callback,
-                                )
+                        )
+                        .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
-                            });
-                        }
-                        Request::CompleteWorkflowActivation {
-                            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 {
-                                    core.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 {
-                            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 {
-                                    core.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 { heartbeat } => {
-                            core.record_activity_heartbeat(heartbeat)
-                        }
-                    }
+                        },
+                        |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,
+                        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)
                 }
             }
         }
@@ -478,15 +465,14 @@ fn start_bridge_loop(
 
 /// Called within the poll loop thread, calls core and triggers JS callback with result
 async fn handle_poll_workflow_activation_request(
-    queue_name: String,
+    worker: &dyn CoreWorker,
     span_context: SpanContext,
-    core: &dyn Core,
     event_queue: Arc<EventQueue>,
     callback: Root<JsFunction>,
 ) {
     let otel_ctx = opentelemetry::Context::new().with_remote_span_context(span_context);
-    match core
-        .poll_workflow_activation(queue_name.as_str())
+    match worker
+        .poll_workflow_activation()
         .with_context(otel_ctx)
         .await
     {
@@ -507,12 +493,7 @@ async fn handle_poll_workflow_activation_request(
             send_error(event_queue, callback, move |cx| match err {
                 PollWfError::ShutDown => SHUTDOWN_ERROR.from_error(cx, err),
                 PollWfError::AutocompleteError(CompleteWfError::NoWorkerForQueue(_)) => {
-                    UNEXPECTED_ERROR
-                        .from_error(cx, format!("No worker registered for queue {}", queue_name))
-                }
-                PollWfError::NoWorkerForQueue(queue_name) => {
-                    let args = vec![cx.string(queue_name).upcast()];
-                    NO_WORKER_ERROR.construct(cx, args)
+                    UNEXPECTED_ERROR.from_error(cx, "TODO this error shouldn't exist")
                 }
                 PollWfError::TonicError(_)
                 | PollWfError::AutocompleteError(CompleteWfError::TonicError(_)) => {
@@ -529,18 +510,13 @@ 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(
-    queue_name: String,
+    worker: &dyn CoreWorker,
     span_context: SpanContext,
-    core: &dyn Core,
     event_queue: Arc<EventQueue>,
     callback: Root<JsFunction>,
 ) {
     let otel_ctx = opentelemetry::Context::new().with_remote_span_context(span_context);
-    match core
-        .poll_activity_task(queue_name.as_str())
-        .with_context(otel_ctx)
-        .await
-    {
+    match worker.poll_activity_task().with_context(otel_ctx).await {
         Ok(task) => {
             send_result(event_queue, callback, move |cx| {
                 let len = task.encoded_len();
@@ -557,10 +533,6 @@ async fn handle_poll_activity_task_request(
         Err(err) => {
             send_error(event_queue, callback, move |cx| match err {
                 PollActivityError::ShutDown => SHUTDOWN_ERROR.from_error(cx, err),
-                PollActivityError::NoWorkerForQueue(queue_name) => {
-                    let args = vec![cx.string(queue_name).upcast()];
-                    NO_WORKER_ERROR.construct(cx, args)
-                }
                 PollActivityError::TonicError(_) => TRANSPORT_ERROR.from_error(cx, err),
             });
         }
@@ -569,61 +541,63 @@ async fn handle_poll_activity_task_request(
 
 // Below are functions exported to JS
 
-/// Create a new core instance asynchronously.
+/// Initialize Core global telemetry.
+/// This should typically be called once on process startup.
+fn init_telemetry(mut cx: FunctionContext) -> JsResult<JsUndefined> {
+    let telemetry_options = cx.argument::<JsObject>(0)?.as_telemetry_options(&mut cx)?;
+    telemetry_init(&telemetry_options).map_err(|err| {
+        cx.throw_type_error::<String, ()>(format!("{}", err))
+            .unwrap_err()
+    })?;
+    Ok(cx.undefined())
+}
+
+/// Create the tokio runtime required to run Core.
 /// Immediately spawns a poller thread that will block on [Request]s
-/// Core is returned to JS using supplied callback
-fn core_new(mut cx: FunctionContext) -> JsResult<JsUndefined> {
-    let core_options = cx.argument::<JsObject>(0)?;
-    let server_options = core_options
-        .get(&mut cx, "serverOptions")?
-        .downcast_or_throw::<JsObject, _>(&mut cx)?;
-    let telem_options = core_options
-        .get(&mut cx, "telemetryOptions")?
-        .downcast_or_throw::<JsObject, _>(&mut cx)?;
-
-    let gateway_opts = server_options.as_server_gateway_options(&mut cx)?;
-    let telemetry_opts = telem_options.as_telemetry_options(&mut cx)?;
-
-    let callback = cx.argument::<JsFunction>(1)?.root(&mut cx);
+fn runtime_new(mut cx: FunctionContext) -> JsResult<BoxedRuntime> {
     let queue = Arc::new(cx.queue());
-    let core_init_fut = async move {
-        let opts = CoreInitOptionsBuilder::default()
-            .gateway_opts(gateway_opts)
-            .telemetry_opts(telemetry_opts)
-            .build()
-            .expect("Core init options must be valid");
-        Ok(CoreType::Real(init(opts).await?))
-    };
-    std::thread::spawn(move || start_bridge_loop(core_init_fut, queue, callback));
+    let (sender, mut receiver) = unbounded_channel::<Request>();
 
-    Ok(cx.undefined())
+    std::thread::spawn(move || start_bridge_loop(queue, &mut receiver));
+
+    Ok(cx.boxed(Arc::new(RuntimeHandle { sender })))
 }
 
-/// Create a new "replay" instance of core, which can only be used for replaying static histories.
-fn replay_core_new(mut cx: FunctionContext) -> JsResult<JsUndefined> {
-    let telem_options = cx.argument::<JsObject>(0)?;
-    let telem_options = telem_options.as_telemetry_options(&mut cx)?;
-    let callback = cx.argument::<JsFunction>(1)?.root(&mut cx);
-    let queue = Arc::new(cx.queue());
-    let core_init_fut = async { Ok(CoreType::Replay(init_core_replay(telem_options))) };
-    std::thread::spawn(move || start_bridge_loop(core_init_fut, queue, callback));
+/// Create a connected gRPC client which can be used to initialize workers.
+/// 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 callback = cx.argument::<JsFunction>(2)?;
+
+    let request = Request::CreateClient {
+        runtime: (**runtime).clone(),
+        options: client_options,
+        callback: callback.root(&mut cx),
+    };
+    if let Err(err) = runtime.sender.send(request) {
+        callback_with_unexpected_error(&mut cx, callback, err)?;
+    };
+
     Ok(cx.undefined())
 }
 
 /// Create a new worker asynchronously.
-/// Worker is registered on supplied core instance and returned to JS using supplied callback.
+/// Worker uses the provided connection and returned to JS using supplied `callback`.
 fn worker_new(mut cx: FunctionContext) -> JsResult<JsUndefined> {
-    let core = cx.argument::<BoxedCore>(0)?;
+    let client = cx.argument::<BoxedClient>(0)?;
     let worker_options = cx.argument::<JsObject>(1)?;
     let callback = cx.argument::<JsFunction>(2)?;
 
     let config = worker_options.as_worker_config(&mut cx)?;
 
-    let request = Request::RegisterWorker {
+    let request = Request::InitWorker {
+        client: client.core_client.clone(),
+        runtime: client.runtime.clone(),
         config,
         callback: callback.root(&mut cx),
     };
-    if let Err(err) = core.sender.send(request) {
+    if let Err(err) = client.runtime.sender.send(request) {
         callback_with_unexpected_error(&mut cx, callback, err)?;
     };
 
@@ -631,10 +605,9 @@ fn worker_new(mut cx: FunctionContext) -> JsResult<JsUndefined> {
 }
 
 /// Create a new replay worker asynchronously.
-/// Worker is registered on supplied core instance and returned to JS using supplied callback.
-/// The provided core instance must be a replay core.
+/// Worker is returned to JS using supplied callback.
 fn replay_worker_new(mut cx: FunctionContext) -> JsResult<JsUndefined> {
-    let core = cx.argument::<BoxedCore>(0)?;
+    let runtime = cx.argument::<BoxedRuntime>(0)?;
     let worker_options = cx.argument::<JsObject>(1)?;
     let history_binary = cx.argument::<JsArrayBuffer>(2)?;
     let callback = cx.argument::<JsFunction>(3)?;
@@ -645,12 +618,13 @@ fn replay_worker_new(mut cx: FunctionContext) -> JsResult<JsUndefined> {
         History::decode_length_delimited(data.as_slice::<u8>())
     }) {
         Ok(history) => {
-            let request = Request::RegisterReplayWorker {
+            let request = Request::InitReplayWorker {
+                runtime: (**runtime).clone(),
                 config,
                 history,
                 callback: callback.root(&mut cx),
             };
-            if let Err(err) = core.sender.send(request) {
+            if let Err(err) = runtime.sender.send(request) {
                 callback_with_unexpected_error(&mut cx, callback, err)?;
             };
         }
@@ -663,26 +637,26 @@ fn replay_worker_new(mut cx: FunctionContext) -> JsResult<JsUndefined> {
 }
 
 /// Shutdown the Core instance and break out of the thread loop
-fn core_shutdown(mut cx: FunctionContext) -> JsResult<JsUndefined> {
-    let core = cx.argument::<BoxedCore>(0)?;
+fn runtime_shutdown(mut cx: FunctionContext) -> JsResult<JsUndefined> {
+    let runtime = cx.argument::<BoxedRuntime>(0)?;
     let callback = cx.argument::<JsFunction>(1)?;
     let request = Request::Shutdown {
         callback: callback.root(&mut cx),
     };
-    if let Err(err) = core.sender.send(request) {
+    if let Err(err) = runtime.sender.send(request) {
         callback_with_unexpected_error(&mut cx, callback, err)?;
     };
     Ok(cx.undefined())
 }
 
 /// Request to drain forwarded logs from core
-fn core_poll_logs(mut cx: FunctionContext) -> JsResult<JsUndefined> {
-    let core = cx.argument::<BoxedCore>(0)?;
+fn poll_logs(mut cx: FunctionContext) -> JsResult<JsUndefined> {
+    let runtime = cx.argument::<BoxedRuntime>(0)?;
     let callback = cx.argument::<JsFunction>(1)?;
     let request = Request::PollLogs {
         callback: callback.root(&mut cx),
     };
-    if let Err(err) = core.sender.send(request) {
+    if let Err(err) = runtime.sender.send(request) {
         callback_with_unexpected_error(&mut cx, callback, err)?;
     }
     Ok(cx.undefined())
@@ -695,11 +669,11 @@ fn worker_poll_workflow_activation(mut cx: FunctionContext) -> JsResult<JsUndefi
     let otel_span = cx.argument::<JsObject>(1)?;
     let callback = cx.argument::<JsFunction>(2)?;
     let request = Request::PollWorkflowActivation {
-        queue_name: worker.queue.clone(),
+        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.core.sender.send(request) {
+    if let Err(err) = worker.runtime.sender.send(request) {
         callback_with_unexpected_error(&mut cx, callback, err)?;
     }
     Ok(cx.undefined())
@@ -712,11 +686,11 @@ fn worker_poll_activity_task(mut cx: FunctionContext) -> JsResult<JsUndefined> {
     let otel_span = cx.argument::<JsObject>(1)?;
     let callback = cx.argument::<JsFunction>(2)?;
     let request = Request::PollActivityTask {
-        queue_name: worker.queue.clone(),
+        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.core.sender.send(request) {
+    if let Err(err) = worker.runtime.sender.send(request) {
         callback_with_unexpected_error(&mut cx, callback, err)?;
     }
     Ok(cx.undefined())
@@ -733,17 +707,13 @@ fn worker_complete_workflow_activation(mut cx: FunctionContext) -> JsResult<JsUn
     });
     match result {
         Ok(completion) => {
-            // Add the task queue from our Worker
-            let completion = WorkflowActivationCompletion {
-                task_queue: worker.queue.clone(),
-                ..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.core.sender.send(request) {
+            if let Err(err) = worker.runtime.sender.send(request) {
                 callback_with_unexpected_error(&mut cx, callback, err)?;
             };
         }
@@ -765,17 +735,13 @@ fn worker_complete_activity_task(mut cx: FunctionContext) -> JsResult<JsUndefine
     });
     match result {
         Ok(completion) => {
-            // Add the task queue from our Worker
-            let completion = ActivityTaskCompletion {
-                task_queue: worker.queue.clone(),
-                ..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.core.sender.send(request) {
+            if let Err(err) = worker.runtime.sender.send(request) {
                 callback_with_unexpected_error(&mut cx, callback, err)?;
             };
         }
@@ -795,13 +761,11 @@ fn worker_record_activity_heartbeat(mut cx: FunctionContext) -> JsResult<JsUndef
     });
     match heartbeat {
         Ok(heartbeat) => {
-            // Add the task queue from our Worker
-            let heartbeat = ActivityHeartbeat {
-                task_queue: worker.queue.clone(),
-                ..heartbeat
+            let request = Request::RecordActivityHeartbeat {
+                worker: worker.core_worker.clone(),
+                heartbeat,
             };
-            let request = Request::RecordActivityHeartbeat { heartbeat };
-            match worker.core.sender.send(request) {
+            match worker.runtime.sender.send(request) {
                 Err(err) => UNEXPECTED_ERROR
                     .from_error(&mut cx, err)
                     .and_then(|err| cx.throw(err)),
@@ -819,8 +783,8 @@ fn worker_record_activity_heartbeat(mut cx: FunctionContext) -> JsResult<JsUndef
 fn worker_shutdown(mut cx: FunctionContext) -> JsResult<JsUndefined> {
     let worker = cx.argument::<BoxedWorker>(0)?;
     let callback = cx.argument::<JsFunction>(1)?;
-    match worker.core.sender.send(Request::ShutdownWorker {
-        task_queue: worker.queue.clone(),
+    match worker.runtime.sender.send(Request::ShutdownWorker {
+        worker: worker.core_worker.clone(),
         callback: callback.root(&mut cx),
     }) {
         Err(err) => cx.throw_error(format!("{}", err)),
@@ -854,13 +818,14 @@ fn get_time_of_day(mut cx: FunctionContext) -> JsResult<JsArray> {
 fn main(mut cx: ModuleContext) -> NeonResult<()> {
     cx.export_function("getTimeOfDay", get_time_of_day)?;
     cx.export_function("registerErrors", errors::register_errors)?;
-    cx.export_function("newCore", core_new)?;
-    cx.export_function("newReplayCore", replay_core_new)?;
+    cx.export_function("initTelemetry", init_telemetry)?;
+    cx.export_function("newRuntime", runtime_new)?;
+    cx.export_function("newClient", client_new)?;
     cx.export_function("newWorker", worker_new)?;
     cx.export_function("newReplayWorker", replay_worker_new)?;
     cx.export_function("workerShutdown", worker_shutdown)?;
-    cx.export_function("coreShutdown", core_shutdown)?;
-    cx.export_function("corePollLogs", core_poll_logs)?;
+    cx.export_function("runtimeShutdown", runtime_shutdown)?;
+    cx.export_function("pollLogs", poll_logs)?;
     cx.export_function(
         "workerPollWorkflowActivation",
         worker_poll_workflow_activation,