@temporalio/core-bridge 1.4.4 → 1.5.1

package/src/runtime.rs

@@ -1,9 +1,8 @@
-use crate::conversions::*;
-use crate::errors::*;
-use crate::helpers::*;
-use crate::worker::*;
+use crate::{conversions::*, errors::*, helpers::*, worker::*};
+use neon::context::Context;
 use neon::prelude::*;
 use parking_lot::RwLock;
+use std::cell::Cell;
 use std::{
     cell::RefCell,
     collections::HashMap,
@@ -12,17 +11,17 @@ use std::{
     time::{Duration, SystemTime, UNIX_EPOCH},
 };
 use temporal_client::{ClientInitError, ConfiguredClient, TemporalServiceClientWithMetrics};
-use temporal_sdk_core::ephemeral_server::EphemeralServer as CoreEphemeralServer;
+use temporal_sdk_core::api::telemetry::{CoreTelemetry, TelemetryOptions};
+use temporal_sdk_core::CoreRuntime;
 use temporal_sdk_core::{
-    fetch_global_buffered_logs, init_replay_worker, init_worker,
-    protos::temporal::api::history::v1::History, telemetry_init, ClientOptions, RetryClient,
-    WorkerConfig,
+    ephemeral_server::EphemeralServer as CoreEphemeralServer, init_replay_worker, init_worker,
+    replay::HistoryForReplay, ClientOptions, RetryClient, WorkerConfig,
 };
-use tokio::{
-    runtime::Runtime,
-    sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender},
-    sync::Mutex,
+use tokio::sync::{
+    mpsc::{channel, unbounded_channel, Sender, UnboundedReceiver, UnboundedSender},
+    Mutex,
 };
+use tokio_stream::wrappers::ReceiverStream;
 
 pub type RawClient = RetryClient<ConfiguredClient<TemporalServiceClientWithMetrics>>;
 
@@ -84,10 +83,9 @@ pub enum RuntimeRequest {
     },
     /// 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
-        history: History,
         /// Used to send the result back into JS
         callback: Root<JsFunction>,
     },
@@ -105,22 +103,27 @@ pub enum RuntimeRequest {
         server: Arc<Mutex<CoreEphemeralServer>>,
         callback: Root<JsFunction>,
     },
-}
-
-/// Inits a multi-threaded tokio runtime used to interact with sdk-core APIs
-pub fn tokio_runtime() -> Runtime {
-    tokio::runtime::Builder::new_multi_thread()
-        .enable_all()
-        .thread_name("core")
-        .build()
-        .expect("Tokio runtime must construct properly")
+    PushReplayHistory {
+        tx: Sender<HistoryForReplay>,
+        pushme: HistoryForReplay,
+        callback: Root<JsFunction>,
+    },
 }
 
 /// 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.
-pub fn start_bridge_loop(channel: Arc<Channel>, receiver: &mut UnboundedReceiver<RuntimeRequest>) {
-    tokio_runtime().block_on(async {
+pub fn start_bridge_loop(
+    telemetry_options: TelemetryOptions,
+    channel: Arc<Channel>,
+    receiver: &mut UnboundedReceiver<RuntimeRequest>,
+) {
+    let mut tokio_builder = tokio::runtime::Builder::new_multi_thread();
+    tokio_builder.enable_all().thread_name("core");
+    let core_runtime =
+        CoreRuntime::new(telemetry_options, tokio_builder).expect("Failed to create CoreRuntime");
+
+    core_runtime.tokio_handle().block_on(async {
         loop {
             let request_option = receiver.recv().await;
             let request = match request_option {
@@ -145,23 +148,25 @@ pub fn start_bridge_loop(channel: Arc<Channel>, receiver: &mut UnboundedReceiver
                     // 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.
-                    tokio::spawn(async move {
+                    core_runtime.tokio_handle().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(
+                                    ClientInitError::SystemInfoCallError(e) => {
+                                        make_named_error_from_string(
                                             cx,
+                                            TRANSPORT_ERROR,
                                             format!("Failed to call GetSystemInfo: {}", e),
-                                        ),
+                                        )
+                                    }
                                     ClientInitError::TonicTransportError(e) => {
-                                        TRANSPORT_ERROR.from_error(cx, e)
+                                        make_named_error_from_error(cx, TRANSPORT_ERROR, e)
                                     }
                                     ClientInitError::InvalidUri(e) => {
-                                        Ok(JsError::type_error(cx, format!("{}", e))?.upcast())
+                                        Ok(JsError::type_error(cx, format!("{}", e))?)
                                     }
                                 });
                             }
@@ -185,7 +190,7 @@ pub fn start_bridge_loop(channel: Arc<Channel>, receiver: &mut UnboundedReceiver
                     send_result(channel.clone(), callback, |cx| Ok(cx.undefined()));
                 }
                 RuntimeRequest::PollLogs { callback } => {
-                    let logs = fetch_global_buffered_logs();
+                    let logs = core_runtime.telemetry().fetch_buffered_logs();
                     send_result(channel.clone(), callback, |cx| {
                         let logarr = cx.empty_array();
                         for (i, cl) in logs.into_iter().enumerate() {
@@ -209,28 +214,49 @@ pub fn start_bridge_loop(channel: Arc<Channel>, receiver: &mut UnboundedReceiver
                     callback,
                 } => {
                     let client = (*client).clone();
-                    let worker = init_worker(config, client.into_inner());
-                    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 }))))
-                    });
+                    match init_worker(&core_runtime, config, client.into_inner()) {
+                        Ok(worker) => {
+                            let (tx, rx) = unbounded_channel();
+                            core_runtime.tokio_handle().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| {
+                            make_named_error_from_error(cx, UNEXPECTED_ERROR, err.deref())
+                        }),
+                    }
                 }
                 RuntimeRequest::InitReplayWorker {
+                    runtime,
                     config,
-                    history,
                     callback,
                 } => {
-                    match init_replay_worker(config, &history) {
+                    let (tunnel, stream) = HistoryForReplayTunnel::new(runtime);
+                    match init_replay_worker(config, Box::pin(stream)) {
                         Ok(worker) => {
                             let (tx, rx) = unbounded_channel();
-                            tokio::spawn(start_worker_loop(worker, rx, channel.clone()));
+                            core_runtime.tokio_handle().spawn(start_worker_loop(
+                                worker,
+                                rx,
+                                channel.clone(),
+                            ));
                             send_result(channel.clone(), callback, |cx| {
-                                Ok(cx.boxed(RefCell::new(Some(WorkerHandle { sender: tx }))))
+                                let worker =
+                                    cx.boxed(RefCell::new(Some(WorkerHandle { sender: tx })));
+                                let tunnel = cx.boxed(tunnel);
+                                let retme = cx.empty_object();
+                                retme.set(cx, "worker", worker)?;
+                                retme.set(cx, "pusher", tunnel)?;
+                                Ok(retme)
                             })
                         }
                         Err(err) => send_error(channel.clone(), callback, move |cx| {
-                            UNEXPECTED_ERROR.from_error(cx, err.deref())
+                            make_named_error_from_error(cx, UNEXPECTED_ERROR, err.deref())
                         }),
                     };
                 }
@@ -239,7 +265,7 @@ pub fn start_bridge_loop(channel: Arc<Channel>, receiver: &mut UnboundedReceiver
                     config,
                     callback,
                 } => {
-                    tokio::spawn(async move {
+                    core_runtime.tokio_handle().spawn(async move {
                         let result = match config {
                             EphemeralServerConfig::TestServer(config) => {
                                 config.start_server().await
@@ -252,7 +278,7 @@ pub fn start_bridge_loop(channel: Arc<Channel>, receiver: &mut UnboundedReceiver
                             Err(err) => {
                                 let err_str = format!("Failed to start ephemeral server: {}", err);
                                 send_error(channel.clone(), callback, |cx| {
-                                    UNEXPECTED_ERROR.from_string(cx, err_str)
+                                    make_named_error_from_string(cx, UNEXPECTED_ERROR, err_str)
                                 });
                             }
                             Ok(server) => {
@@ -267,7 +293,7 @@ pub fn start_bridge_loop(channel: Arc<Channel>, receiver: &mut UnboundedReceiver
                     });
                 }
                 RuntimeRequest::ShutdownEphemeralServer { server, callback } => {
-                    tokio::spawn(async move {
+                    core_runtime.tokio_handle().spawn(async move {
                         void_future_to_js(
                             channel,
                             callback,
@@ -276,8 +302,9 @@ pub fn start_bridge_loop(channel: Arc<Channel>, receiver: &mut UnboundedReceiver
                                 guard.shutdown().await
                             },
                             |cx, err| {
-                                UNEXPECTED_ERROR.from_string(
+                                make_named_error_from_string(
                                     cx,
+                                    UNEXPECTED_ERROR,
                                     format!("Failed to start test server: {}", err),
                                 )
                             },
@@ -285,6 +312,30 @@ pub fn start_bridge_loop(channel: Arc<Channel>, receiver: &mut UnboundedReceiver
                         .await
                     });
                 }
+                RuntimeRequest::PushReplayHistory {
+                    tx,
+                    pushme,
+                    callback,
+                } => {
+                    core_runtime.tokio_handle().spawn(async move {
+                        let sendfut = async move {
+                            tx.send(pushme).await.map_err(|e| {
+                                format!(
+                    "Receive side of history replay channel is gone. This is an sdk bug. {:?}",
+                    e
+                                )
+                            })
+                        };
+                        void_future_to_js(channel, callback, sendfut, |cx, err| {
+                            make_named_error_from_string(
+                                cx,
+                                UNEXPECTED_ERROR,
+                                format!("Error pushing replay history {}", err),
+                            )
+                        })
+                        .await
+                    });
+                }
             }
         }
     })
@@ -314,24 +365,15 @@ pub fn get_time_of_day(mut cx: FunctionContext) -> JsResult<JsArray> {
     system_time_to_js(&mut cx, SystemTime::now())
 }
 
-/// Initialize Core global telemetry.
+/// Initialize Core global telemetry and create the tokio runtime required to run Core.
 /// This should typically be called once on process startup.
-pub 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 [RuntimeRequest]s
 pub fn runtime_new(mut cx: FunctionContext) -> JsResult<BoxedRuntime> {
+    let telemetry_options = cx.argument::<JsObject>(0)?.as_telemetry_options(&mut cx)?;
     let channel = Arc::new(cx.channel());
     let (sender, mut receiver) = unbounded_channel::<RuntimeRequest>();
 
-    std::thread::spawn(move || start_bridge_loop(channel, &mut receiver));
+    std::thread::spawn(move || start_bridge_loop(telemetry_options, channel, &mut receiver));
 
     Ok(cx.boxed(Arc::new(RuntimeHandle { sender })))
 }
@@ -401,8 +443,7 @@ pub fn client_new(mut cx: FunctionContext) -> JsResult<JsUndefined> {
 pub fn client_close(mut cx: FunctionContext) -> JsResult<JsUndefined> {
     let client = cx.argument::<BoxedClient>(0)?;
     if client.replace(None).is_none() {
-        ILLEGAL_STATE_ERROR
-            .from_string(&mut cx, "Client already closed")
+        make_named_error_from_string(&mut cx, ILLEGAL_STATE_ERROR, "Client already closed")
             .and_then(|err| cx.throw(err))?;
     };
     Ok(cx.undefined())
@@ -434,3 +475,33 @@ pub fn client_update_headers(mut cx: FunctionContext) -> JsResult<JsUndefined> {
 
     Ok(cx.undefined())
 }
+
+pub(crate) struct HistoryForReplayTunnel {
+    pub(crate) runtime: Arc<RuntimeHandle>,
+    sender: Cell<Option<Sender<HistoryForReplay>>>,
+}
+impl HistoryForReplayTunnel {
+    fn new(runtime: Arc<RuntimeHandle>) -> (Self, ReceiverStream<HistoryForReplay>) {
+        let (sender, rx) = channel(1);
+        (
+            HistoryForReplayTunnel {
+                runtime,
+                sender: Cell::new(Some(sender)),
+            },
+            ReceiverStream::new(rx),
+        )
+    }
+    pub fn get_chan(&self) -> Result<Sender<HistoryForReplay>, &'static str> {
+        let chan = self.sender.take();
+        self.sender.set(chan.clone());
+        if let Some(chan) = chan {
+            Ok(chan)
+        } else {
+            Err("History replay channel is already closed")
+        }
+    }
+    pub fn shutdown(&self) {
+        self.sender.take();
+    }
+}
+impl Finalize for HistoryForReplayTunnel {}

package/src/testing.rs

@@ -32,11 +32,14 @@ pub fn get_ephemeral_server_target(mut cx: FunctionContext) -> JsResult<JsString
     let target = server
         .borrow()
         .as_ref()
-        .map(|s| cx.string(s.core_server.blocking_lock().target.to_owned()));
+        .map(|s| cx.string(s.core_server.blocking_lock().target.as_str()));
     if target.is_none() {
-        ILLEGAL_STATE_ERROR
-            .from_string(&mut cx, "Tried to use closed test server")
-            .and_then(|err| cx.throw(err))?;
+        make_named_error_from_string(
+            &mut cx,
+            ILLEGAL_STATE_ERROR,
+            "Tried to use closed test server",
+        )
+        .and_then(|err| cx.throw(err))?;
     };
     Ok(target.unwrap())
 }

package/src/worker.rs

@@ -1,13 +1,10 @@
-use crate::conversions::ObjectHandleConversionsExt;
-use crate::errors::*;
-use crate::helpers::*;
-use crate::runtime::*;
+use crate::{conversions::ObjectHandleConversionsExt, errors::*, helpers::*, runtime::*};
 use futures::stream::StreamExt;
-use neon::prelude::*;
-use neon::types::buffer::TypedArray;
+use neon::{prelude::*, types::buffer::TypedArray};
 use opentelemetry::trace::{FutureExt, SpanContext, TraceContextExt};
 use prost::Message;
 use std::{cell::RefCell, sync::Arc};
+use temporal_sdk_core::replay::HistoryForReplay;
 use temporal_sdk_core::{
     api::{
         errors::{CompleteActivityError, CompleteWfError, PollActivityError, PollWfError},
@@ -96,7 +93,7 @@ pub async fn start_worker_loop(
                         callback,
                     } => {
                         handle_poll_workflow_activation_request(
-                            &worker, otel_span, channel, callback,
+                            worker, otel_span, channel, callback,
                         )
                         .await
                     }
@@ -104,7 +101,7 @@ pub async fn start_worker_loop(
                         otel_span,
                         callback,
                     } => {
-                        handle_poll_activity_task_request(&worker, otel_span, channel, callback)
+                        handle_poll_activity_task_request(worker, otel_span, channel, callback)
                             .await
                     }
                     WorkerRequest::CompleteWorkflowActivation {
@@ -196,12 +193,12 @@ async fn handle_poll_workflow_activation_request(
         }
         Err(err) => {
             send_error(channel, callback, move |cx| match err {
-                PollWfError::ShutDown => SHUTDOWN_ERROR.from_error(cx, err),
-                PollWfError::TonicError(_) => TRANSPORT_ERROR.from_error(cx, err),
+                PollWfError::ShutDown => make_named_error_from_error(cx, SHUTDOWN_ERROR, err),
+                PollWfError::TonicError(_) => make_named_error_from_error(cx, TRANSPORT_ERROR, err),
                 PollWfError::AutocompleteError(CompleteWfError::MalformedWorkflowCompletion {
                     reason,
                     ..
-                }) => Ok(JsError::type_error(cx, reason)?.upcast()),
+                }) => Ok(JsError::type_error(cx, reason)?),
             });
         }
     }
@@ -229,8 +226,10 @@ pub async fn handle_poll_activity_task_request(
         }
         Err(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),
+                PollActivityError::ShutDown => make_named_error_from_error(cx, SHUTDOWN_ERROR, err),
+                PollActivityError::TonicError(_) => {
+                    make_named_error_from_error(cx, TRANSPORT_ERROR, err)
+                }
             });
         }
     }
@@ -270,27 +269,51 @@ pub fn worker_new(mut cx: FunctionContext) -> JsResult<JsUndefined> {
 pub fn replay_worker_new(mut cx: FunctionContext) -> JsResult<JsUndefined> {
     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)?;
+    let callback = cx.argument::<JsFunction>(2)?;
 
     let config = worker_options.as_worker_config(&mut cx)?;
-    let data = history_binary.as_slice(&mut cx);
+    let request = RuntimeRequest::InitReplayWorker {
+        runtime: (*runtime).clone(),
+        config,
+        callback: callback.root(&mut cx),
+    };
+    if let Err(err) = runtime.sender.send(request) {
+        callback_with_unexpected_error(&mut cx, callback, err)?;
+    };
+
+    Ok(cx.undefined())
+}
+
+pub fn push_history(mut cx: FunctionContext) -> JsResult<JsUndefined> {
+    let pusher = cx.argument::<JsBox<HistoryForReplayTunnel>>(0)?;
+    let workflow_id = cx.argument::<JsString>(1)?;
+    let history_binary = cx.argument::<JsArrayBuffer>(2)?;
+    let callback = cx.argument::<JsFunction>(3)?;
+    let data = history_binary.as_slice(&cx);
     match History::decode_length_delimited(data) {
-        Ok(history) => {
-            let request = RuntimeRequest::InitReplayWorker {
-                config,
-                history,
-                callback: callback.root(&mut cx),
-            };
-            if let Err(err) = runtime.sender.send(request) {
-                callback_with_unexpected_error(&mut cx, callback, err)?;
-            };
+        Ok(hist) => {
+            let workflow_id = workflow_id.value(&mut cx);
+            if let Err(e) = pusher.get_chan().map(|chan| {
+                pusher
+                    .runtime
+                    .sender
+                    .send(RuntimeRequest::PushReplayHistory {
+                        tx: chan,
+                        pushme: HistoryForReplay::new(hist, workflow_id),
+                        callback: callback.root(&mut cx),
+                    })
+            }) {
+                callback_with_unexpected_error(&mut cx, callback, e)?;
+            }
+            Ok(cx.undefined())
         }
-        Err(_) => callback_with_error(&mut cx, callback, |cx| {
-            JsError::type_error(cx, "Cannot decode History from buffer")
-        })?,
+        Err(e) => cx.throw_error(format!("Error decoding history: {:?}", e)),
     }
+}
 
+pub fn close_history_stream(mut cx: FunctionContext) -> JsResult<JsUndefined> {
+    let pusher = cx.argument::<JsBox<HistoryForReplayTunnel>>(0)?;
+    pusher.shutdown();
     Ok(cx.undefined())
 }
 
@@ -351,9 +374,7 @@ pub fn worker_complete_workflow_activation(mut cx: FunctionContext) -> JsResult<
             callback_with_unexpected_error(&mut cx, callback, "Tried to use closed Worker")?;
         }
         Some(worker) => {
-            match WorkflowActivationCompletion::decode_length_delimited(
-                completion.as_slice(&mut cx),
-            ) {
+            match WorkflowActivationCompletion::decode_length_delimited(completion.as_slice(&cx)) {
                 Ok(completion) => {
                     let request = WorkerRequest::CompleteWorkflowActivation {
                         completion,
@@ -384,7 +405,7 @@ pub fn worker_complete_activity_task(mut cx: FunctionContext) -> JsResult<JsUnde
             callback_with_unexpected_error(&mut cx, callback, "Tried to use closed Worker")?;
         }
         Some(worker) => {
-            match ActivityTaskCompletion::decode_length_delimited(result.as_slice(&mut cx)) {
+            match ActivityTaskCompletion::decode_length_delimited(result.as_slice(&cx)) {
                 Ok(completion) => {
                     let request = WorkerRequest::CompleteActivityTask {
                         completion,
@@ -409,22 +430,20 @@ pub fn worker_record_activity_heartbeat(mut cx: FunctionContext) -> JsResult<JsU
     let worker = cx.argument::<BoxedWorker>(0)?;
     let heartbeat = cx.argument::<JsArrayBuffer>(1)?;
     match worker.borrow().as_ref() {
-        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))?;
-                    }
+        None => {
+            make_named_error_from_string(&mut cx, UNEXPECTED_ERROR, "Tried to use closed Worker")
+                .and_then(|err| cx.throw(err))?
+        }
+        Some(worker) => match ActivityHeartbeat::decode_length_delimited(heartbeat.as_slice(&cx)) {
+            Ok(heartbeat) => {
+                let request = WorkerRequest::RecordActivityHeartbeat { heartbeat };
+                if let Err(err) = worker.sender.send(request) {
+                    make_named_error_from_error(&mut cx, UNEXPECTED_ERROR, 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())
 }
@@ -444,8 +463,7 @@ pub fn worker_initiate_shutdown(mut cx: FunctionContext) -> JsResult<JsUndefined
             if let Err(err) = worker.sender.send(WorkerRequest::InitiateShutdown {
                 callback: callback.root(&mut cx),
             }) {
-                UNEXPECTED_ERROR
-                    .from_error(&mut cx, err)
+                make_named_error_from_error(&mut cx, UNEXPECTED_ERROR, err)
                     .and_then(|err| cx.throw(err))?;
             };
         }
@@ -456,8 +474,7 @@ pub fn worker_initiate_shutdown(mut cx: FunctionContext) -> JsResult<JsUndefined
 pub 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")
+        make_named_error_from_string(&mut cx, ILLEGAL_STATE_ERROR, "Worker already closed")
             .and_then(|err| cx.throw(err))?;
     }
 

package/ts/errors.ts

@@ -0,0 +1,55 @@
+import { IllegalStateError } from '@temporalio/common';
+
+/**
+ * The worker has been shut down
+ */
+export class ShutdownError extends Error {
+  public readonly name = 'ShutdownError';
+}
+
+/**
+ * Thrown after shutdown was requested as a response to a poll function, JS should stop polling
+ * once this error is encountered
+ */
+export class TransportError extends Error {
+  public readonly name = 'TransportError';
+}
+
+/**
+ * Something unexpected happened, considered fatal
+ */
+export class UnexpectedError extends Error {
+  public readonly name = 'UnexpectedError';
+}
+export { IllegalStateError };
+
+export function convertFromNamedError(e: unknown, keepStackTrace: boolean): unknown {
+  // Check if the error's class is exactly Error (not a descendant of it).
+  // The instanceof check both ensure that e is indeed an object AND avoid
+  // TypeScript from complaining on accessing Error properties.
+  if (e instanceof Error && Object.getPrototypeOf(e).name === 'Error') {
+    let newerr: Error;
+    switch (e.name) {
+      case 'TransportError':
+        newerr = new TransportError(e.message);
+        newerr.stack = keepStackTrace ? e.stack : undefined;
+        return newerr;
+
+      case 'IllegalStateError':
+        newerr = new IllegalStateError(e.message);
+        newerr.stack = keepStackTrace ? e.stack : undefined;
+        return newerr;
+
+      case 'ShutdownError':
+        newerr = new ShutdownError(e.message);
+        newerr.stack = keepStackTrace ? e.stack : undefined;
+        return newerr;
+
+      case 'UnexpectedError':
+        newerr = new UnexpectedError(e.message);
+        newerr.stack = keepStackTrace ? e.stack : undefined;
+        return newerr;
+    }
+  }
+  return e;
+}