@temporalio/core-bridge 0.16.4 → 0.18.0

package/src/lib.rs

@@ -4,27 +4,42 @@ mod errors;
 use crate::conversions::ObjectHandleConversionsExt;
 use errors::*;
 use neon::prelude::*;
+use once_cell::sync::OnceCell;
 use opentelemetry::trace::{FutureExt, SpanContext, TraceContextExt};
 use prost::Message;
 use std::{
     fmt::Display,
     future::Future,
+    ops::Deref,
     sync::Arc,
     time::{Duration, SystemTime, UNIX_EPOCH},
 };
 use temporal_sdk_core::{
-    errors::{
-        CompleteActivityError, CompleteWfError, CoreInitError, PollActivityError, PollWfError,
+    api::{
+        errors::{
+            CompleteActivityError, CompleteWfError, CoreInitError, PollActivityError, PollWfError,
+        },
+        Core,
     },
-    init, Core, CoreInitOptions, CoreInitOptionsBuilder, WorkerConfig,
+    init,
+    protos::{
+        coresdk::{
+            workflow_completion::WorkflowActivationCompletion, ActivityHeartbeat,
+            ActivityTaskCompletion,
+        },
+        temporal::api::history::v1::History,
+    },
+    replay::{init_core_replay, ReplayCore, ReplayCoreImpl},
+    CoreInitOptionsBuilder, CoreSDK, WorkerConfig,
 };
-use temporal_sdk_core_protos::coresdk::{
-    workflow_completion::WfActivationCompletion, ActivityHeartbeat, ActivityTaskCompletion,
+use tokio::{
+    runtime::Runtime,
+    sync::mpsc::{unbounded_channel, UnboundedSender},
 };
-use tokio::sync::mpsc::{unbounded_channel, UnboundedSender};
 
 /// A request from JS to bridge to core
-pub enum Request {
+#[derive(Debug)]
+enum Request {
     /// A request to shutdown Core, any registered workers will be shutdown as well.
     /// Breaks from the thread loop.
     Shutdown {
@@ -45,6 +60,15 @@ pub enum Request {
         /// 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 {
+        /// Worker configuration. Must have unique task queue name.
+        config: WorkerConfig,
+        /// The history this worker should replay
+        history: History,
+        /// Used to send the result back into JS
+        callback: Root<JsFunction>,
+    },
     /// A request to poll for workflow activations
     PollWorkflowActivation {
         /// Name of queue to poll on
@@ -55,7 +79,7 @@ pub enum Request {
     },
     /// A request to complete a single workflow activation
     CompleteWorkflowActivation {
-        completion: WfActivationCompletion,
+        completion: WorkflowActivationCompletion,
         otel_span: SpanContext,
         /// Used to send the result back into JS
         callback: Root<JsFunction>,
@@ -85,27 +109,51 @@ pub enum Request {
 }
 
 #[derive(Clone)]
-pub struct CoreHandle {
+struct CoreHandle {
     sender: UnboundedSender<Request>,
 }
-
 /// Box it so we can use Core from JS
 type BoxedCore = JsBox<CoreHandle>;
-
 impl Finalize for CoreHandle {}
 
 /// Worker struct, hold a reference for the channel sender responsible for sending requests from
 /// JS to a bridge thread which forwards them to core
-pub struct Worker {
+struct Worker {
     core: CoreHandle,
     queue: String,
 }
-
 /// 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();
+    INSTANCE.get_or_init(|| {
+        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)
 where
@@ -196,222 +244,243 @@ async fn void_future_to_js<E, F, ER, EF>(
 /// 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_options: CoreInitOptions,
+    core_init_fut: impl Future<Output = Result<CoreType, CoreInitError>>,
     event_queue: Arc<EventQueue>,
     callback: Root<JsFunction>,
 ) {
     let (sender, mut receiver) = unbounded_channel::<Request>();
 
-    tokio::runtime::Builder::new_multi_thread()
-        .enable_all()
-        .build()
-        .unwrap()
-        .block_on(async {
-            match init(core_init_options).await {
-                Err(err) => {
-                    send_error(event_queue.clone(), callback, |cx| match err {
-                        CoreInitError::InvalidUri(_) => {
-                            Ok(JsError::type_error(cx, "Invalid URI")?.upcast())
+    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,
+                    };
+
+                    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;
                         }
-                        CoreInitError::TonicTransportError(err) => {
-                            TRANSPORT_ERROR.from_error(cx, err)
+                        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();
+                                }
+                                Ok(logarr)
+                            });
                         }
-                        e @ CoreInitError::TelemetryInitError(_) => {
-                            UNEXPECTED_ERROR.from_error(cx, e)
+                        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(result) => {
-                    let core = Arc::new(result);
-                    let core_handle = CoreHandle {
-                        sender: sender.clone(),
-                    };
-                    // 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,
-                        };
-                        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),
+                        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::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."
                                 )
-                                .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();
-                                    }
-                                    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),
-                                ));
-                            }
-                            Request::RegisterWorker { config, callback } => {
-                                let task_queue = config.clone().task_queue;
-                                let core_handle = core_handle.clone();
-                                tokio::spawn(async move {
-                                    match core.register_worker(config).await {
-                                        Ok(_) => send_result(event_queue.clone(), callback, |cx| {
+                            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)
-                                            })
-                                        }
-                                    };
-                                });
+                                        })
+                                    }
+                                    Err(err) => send_error(event_queue.clone(), callback, |cx| {
+                                        UNEXPECTED_ERROR.from_error(cx, err)
+                                    }),
+                                };
                             }
-                            Request::PollWorkflowActivation {
-                                queue_name,
-                                otel_span,
-                                callback,
-                            } => {
-                                tokio::spawn(handle_poll_workflow_activation_request(
+                        },
+                        Request::PollWorkflowActivation {
+                            queue_name,
+                            otel_span,
+                            callback,
+                        } => {
+                            // dbg!(&queue_name);
+                            tokio::spawn(async move {
+                                handle_poll_workflow_activation_request(
                                     queue_name,
                                     otel_span,
-                                    core,
+                                    core.as_ref().deref(),
                                     event_queue,
                                     callback,
-                                ));
-                            }
-                            Request::PollActivityTask {
-                                queue_name,
-                                otel_span,
-                                callback,
-                            } => {
-                                tokio::spawn(handle_poll_activity_task_request(
+                                )
+                                .await
+                            });
+                        }
+                        Request::PollActivityTask {
+                            queue_name,
+                            otel_span,
+                            callback,
+                        } => {
+                            tokio::spawn(async move {
+                                handle_poll_activity_task_request(
                                     queue_name,
                                     otel_span,
-                                    core,
+                                    core.as_ref().deref(),
                                     event_queue,
                                     callback,
-                                ));
-                            }
-                            Request::CompleteWorkflowActivation {
-                                completion,
-                                otel_span,
+                                )
+                                .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,
-                            } => {
-                                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,
+                                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,
-                            } => {
-                                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)
-                            }
+                                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)
                         }
                     }
                 }
             }
-        })
+        }
+    })
 }
 
 /// Called within the poll loop thread, calls core and triggers JS callback with result
 async fn handle_poll_workflow_activation_request(
     queue_name: String,
     span_context: SpanContext,
-    core: Arc<impl Core>,
+    core: &dyn Core,
     event_queue: Arc<EventQueue>,
     callback: Root<JsFunction>,
 ) {
@@ -462,7 +531,7 @@ async fn handle_poll_workflow_activation_request(
 async fn handle_poll_activity_task_request(
     queue_name: String,
     span_context: SpanContext,
-    core: Arc<impl Core>,
+    core: &dyn Core,
     event_queue: Arc<EventQueue>,
     callback: Root<JsFunction>,
 ) {
@@ -517,21 +586,30 @@ fn core_new(mut cx: FunctionContext) -> JsResult<JsUndefined> {
 
     let callback = cx.argument::<JsFunction>(1)?.root(&mut cx);
     let queue = Arc::new(cx.queue());
-    std::thread::spawn(move || {
-        start_bridge_loop(
-            CoreInitOptionsBuilder::default()
-                .gateway_opts(gateway_opts)
-                .telemetry_opts(telemetry_opts)
-                .build()
-                .expect("Core init options must be valid"),
-            queue,
-            callback,
-        )
-    });
+    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));
 
     Ok(cx.undefined())
 }
 
+/// 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));
+    Ok(cx.undefined())
+}
+
 /// Create a new worker asynchronously.
 /// Worker is registered on supplied core instance and returned to JS using supplied callback.
 fn worker_new(mut cx: FunctionContext) -> JsResult<JsUndefined> {
@@ -552,6 +630,38 @@ fn worker_new(mut cx: FunctionContext) -> JsResult<JsUndefined> {
     Ok(cx.undefined())
 }
 
+/// 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.
+fn replay_worker_new(mut cx: FunctionContext) -> JsResult<JsUndefined> {
+    let core = cx.argument::<BoxedCore>(0)?;
+    let worker_options = cx.argument::<JsObject>(1)?;
+    let history_binary = cx.argument::<JsArrayBuffer>(2)?;
+    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>())
+    }) {
+        Ok(history) => {
+            let request = Request::RegisterReplayWorker {
+                config,
+                history,
+                callback: callback.root(&mut cx),
+            };
+            if let Err(err) = core.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 History from buffer")
+        })?,
+    }
+
+    Ok(cx.undefined())
+}
+
 /// 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)?;
@@ -619,12 +729,12 @@ fn worker_complete_workflow_activation(mut cx: FunctionContext) -> JsResult<JsUn
     let completion = cx.argument::<JsArrayBuffer>(2)?;
     let callback = cx.argument::<JsFunction>(3)?;
     let result = cx.borrow(&completion, |data| {
-        WfActivationCompletion::decode_length_delimited(data.as_slice::<u8>())
+        WorkflowActivationCompletion::decode_length_delimited(data.as_slice::<u8>())
     });
     match result {
         Ok(completion) => {
             // Add the task queue from our Worker
-            let completion = WfActivationCompletion {
+            let completion = WorkflowActivationCompletion {
                 task_queue: worker.queue.clone(),
                 ..completion
             };
@@ -634,7 +744,7 @@ fn worker_complete_workflow_activation(mut cx: FunctionContext) -> JsResult<JsUn
                 callback: callback.root(&mut cx),
             };
             if let Err(err) = worker.core.sender.send(request) {
-                callback_with_error(&mut cx, callback, |cx| UNEXPECTED_ERROR.from_error(cx, err))?;
+                callback_with_unexpected_error(&mut cx, callback, err)?;
             };
         }
         Err(_) => callback_with_error(&mut cx, callback, |cx| {
@@ -732,7 +842,7 @@ where
     let ts = cx.empty_array();
     ts.set(cx, 0, ts_seconds).unwrap();
     ts.set(cx, 1, only_nanos).unwrap();
-    return Ok(ts);
+    Ok(ts)
 }
 
 /// Helper to get the current time in nanosecond resolution.
@@ -745,7 +855,9 @@ 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("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)?;