@temporalio/core-bridge 1.4.3 → 1.5.0

package/Cargo.toml

@@ -20,7 +20,7 @@ incremental = false
 futures = { version = "0.3", features = ["executor"] }
 log = "0.4"
 neon = { version = "0.10", default-features = false, features = ["napi-6", "event-queue-api"] }
-opentelemetry = "0.16"
+opentelemetry = "0.18"
 parking_lot = "0.12"
 prost = "0.11"
 prost-types = "0.11"

package/index.js

@@ -1,8 +1,31 @@
 const { getPrebuiltPath } = require('./common');
+const typescriptExports = require('./lib/index');
+const { convertFromNamedError } = require('./lib/errors');
+
+function wrapErrors(fn) {
+  return (...args) => {
+    try {
+      // Some of our native functions expect callback functions. When present, these callbacks are
+      // always the last argument passed to the function, and always adhere to the signature
+      // `callback(err, result)`. If a callback is present, then make sure that errors sent
+      // to it are also converted.
+      if (typeof args[args.length - 1] === 'function') {
+        const callback = args[args.length - 1];
+        args[args.length - 1] = (e, x) => callback(convertFromNamedError(e, false), x);
+      }
+      return fn(...args);
+    } catch (e) {
+      throw convertFromNamedError(e, true);
+    }
+  };
+}
 
 try {
-  const prebuiltPath = getPrebuiltPath();
-  module.exports = require(prebuiltPath);
+  const nativeLibPath = getPrebuiltPath();
+  const nativeExports = Object.fromEntries(
+    Object.entries(require(nativeLibPath)).map(([name, fn]) => [name, wrapErrors(fn)])
+  );
+  module.exports = { ...typescriptExports, ...nativeExports };
 } catch (err) {
   throw err;
 }

package/lib/errors.d.ts

@@ -0,0 +1,22 @@
+import { IllegalStateError } from '@temporalio/common';
+/**
+ * The worker has been shut down
+ */
+export declare class ShutdownError extends Error {
+    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 declare class TransportError extends Error {
+    readonly name = "TransportError";
+}
+/**
+ * Something unexpected happened, considered fatal
+ */
+export declare class UnexpectedError extends Error {
+    readonly name = "UnexpectedError";
+}
+export { IllegalStateError };
+export declare function convertFromNamedError(e: unknown, keepStackTrace: boolean): unknown;

package/lib/errors.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertFromNamedError = exports.IllegalStateError = exports.UnexpectedError = exports.TransportError = exports.ShutdownError = void 0;
+const common_1 = require("@temporalio/common");
+Object.defineProperty(exports, "IllegalStateError", { enumerable: true, get: function () { return common_1.IllegalStateError; } });
+/**
+ * The worker has been shut down
+ */
+class ShutdownError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = 'ShutdownError';
+    }
+}
+exports.ShutdownError = ShutdownError;
+/**
+ * Thrown after shutdown was requested as a response to a poll function, JS should stop polling
+ * once this error is encountered
+ */
+class TransportError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = 'TransportError';
+    }
+}
+exports.TransportError = TransportError;
+/**
+ * Something unexpected happened, considered fatal
+ */
+class UnexpectedError extends Error {
+    constructor() {
+        super(...arguments);
+        this.name = 'UnexpectedError';
+    }
+}
+exports.UnexpectedError = UnexpectedError;
+function convertFromNamedError(e, keepStackTrace) {
+    // 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;
+        switch (e.name) {
+            case 'TransportError':
+                newerr = new TransportError(e.message);
+                newerr.stack = keepStackTrace ? e.stack : undefined;
+                return newerr;
+            case 'IllegalStateError':
+                newerr = new common_1.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;
+}
+exports.convertFromNamedError = convertFromNamedError;
+//# sourceMappingURL=errors.js.map

package/lib/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../ts/errors.ts"],"names":[],"mappings":";;;AAAA,+CAAuD;AAuB9C,kGAvBA,0BAAiB,OAuBA;AArB1B;;GAEG;AACH,MAAa,aAAc,SAAQ,KAAK;IAAxC;;QACkB,SAAI,GAAG,eAAe,CAAC;IACzC,CAAC;CAAA;AAFD,sCAEC;AAED;;;GAGG;AACH,MAAa,cAAe,SAAQ,KAAK;IAAzC;;QACkB,SAAI,GAAG,gBAAgB,CAAC;IAC1C,CAAC;CAAA;AAFD,wCAEC;AAED;;GAEG;AACH,MAAa,eAAgB,SAAQ,KAAK;IAA1C;;QACkB,SAAI,GAAG,iBAAiB,CAAC;IAC3C,CAAC;CAAA;AAFD,0CAEC;AAGD,SAAgB,qBAAqB,CAAC,CAAU,EAAE,cAAuB;IACvE,wEAAwE;IACxE,wEAAwE;IACxE,6DAA6D;IAC7D,IAAI,CAAC,YAAY,KAAK,IAAI,MAAM,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,OAAO,EAAE;QACnE,IAAI,MAAa,CAAC;QAClB,QAAQ,CAAC,CAAC,IAAI,EAAE;YACd,KAAK,gBAAgB;gBACnB,MAAM,GAAG,IAAI,cAAc,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;gBACvC,MAAM,CAAC,KAAK,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;gBACpD,OAAO,MAAM,CAAC;YAEhB,KAAK,mBAAmB;gBACtB,MAAM,GAAG,IAAI,0BAAiB,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;gBAC1C,MAAM,CAAC,KAAK,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;gBACpD,OAAO,MAAM,CAAC;YAEhB,KAAK,eAAe;gBAClB,MAAM,GAAG,IAAI,aAAa,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;gBACtC,MAAM,CAAC,KAAK,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;gBACpD,OAAO,MAAM,CAAC;YAEhB,KAAK,iBAAiB;gBACpB,MAAM,GAAG,IAAI,eAAe,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;gBACxC,MAAM,CAAC,KAAK,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC;gBACpD,OAAO,MAAM,CAAC;SACjB;KACF;IACD,OAAO,CAAC,CAAC;AACX,CAAC;AA7BD,sDA6BC"}

package/lib/index.d.ts

@@ -0,0 +1,440 @@
+import { SpanContext } from '@opentelemetry/api';
+import type { TLSConfig } from '@temporalio/common/lib/internal-non-workflow';
+export { TLSConfig };
+declare type Shadow<Base, New> = Base extends object ? New extends object ? {
+    [K in keyof Base | keyof New]: K extends keyof Base ? K extends keyof New ? Shadow<Base[K], New[K]> : Base[K] : K extends keyof New ? New[K] : never;
+} : New : New;
+export interface RetryOptions {
+    /** Initial wait time before the first retry. */
+    initialInterval: number;
+    /**
+     * Randomization jitter that is used as a multiplier for the current retry interval
+     * and is added or subtracted from the interval length.
+     */
+    randomizationFactor: number;
+    /** Rate at which retry time should be increased, until it reaches max_interval. */
+    multiplier: number;
+    /** Maximum amount of time to wait between retries. */
+    maxInterval: number;
+    /** Maximum total amount of time requests should be retried for, if None is set then no limit will be used. */
+    maxElapsedTime?: number;
+    /** Maximum number of retry attempts. */
+    maxRetries: number;
+}
+export interface ClientOptions {
+    /**
+     * The URL of the Temporal server to connect to
+     */
+    url: string;
+    /** Version string for the whole node SDK. Should never be set by user */
+    sdkVersion: string;
+    /**
+     * TLS configuration options.
+     *
+     * Pass undefined to use a non-encrypted connection or an empty object to
+     * connect with TLS without any customization.
+     */
+    tls?: TLSConfig;
+    /**
+     * Optional retry options for server requests.
+     */
+    retry?: RetryOptions;
+    /**
+     * Optional mapping of gRPC metadata (HTTP headers) to send with each request to the server.
+     *
+     * Set statically at connection time, can be replaced later using {@link clientUpdateHeaders}.
+     */
+    metadata?: Record<string, string>;
+}
+/**
+ * Log directly to console
+ *
+ * @experimental
+ */
+export interface ConsoleLogger {
+    console: {};
+}
+/**
+ * Forward logs to {@link Runtime} logger
+ *
+ * @experimental
+ */
+export interface ForwardLogger {
+    forward: {
+        /**
+         * What level, if any, logs should be forwarded from core at
+         *
+         * @deprecated Use {@link TelemetryOptions.logging.filter} instead
+         */
+        level?: LogLevel;
+    };
+}
+/**
+ * Logger types supported by Core
+ *
+ * @experimental
+ */
+export declare type Logger = ConsoleLogger | ForwardLogger;
+/**
+ * OpenTelemetry Collector options for exporting metrics or traces
+ *
+ * @experimental
+ */
+export interface OtelCollectorExporter {
+    otel: {
+        /**
+         * URL of a gRPC OpenTelemetry collector.
+         */
+        url: string;
+        /**
+         * Optional set of HTTP request headers to send to Collector (e.g. for authentication)
+         */
+        headers?: Record<string, string>;
+        /**
+         * Specify how frequently in metrics should be exported.
+         *
+         * @format number of milliseconds or {@link https://www.npmjs.com/package/ms | ms-formatted string}
+         * @defaults 1 second
+         */
+        metricsExportInterval?: string | number;
+    };
+}
+/** @experimental */
+export declare type CompiledOtelTraceExporter = Shadow<OtelCollectorExporter, {
+    otel: {
+        metricsExportInterval?: never;
+    };
+}>;
+/** @experimental */
+export declare type CompiledOtelMetricsExporter = Shadow<OtelCollectorExporter, {
+    otel: {
+        metricsExportInterval: number;
+    };
+}>;
+/**
+ * Prometheus metrics exporter options
+ *
+ * @experimental
+ */
+export interface PrometheusMetricsExporter {
+    prometheus: {
+        /**
+         * Address to bind the Prometheus HTTP metrics exporter server
+         * (for example, `0.0.0.0:1234`).
+         *
+         * Metrics will be available for scraping under the standard `/metrics` route.
+         */
+        bindAddress: string;
+    };
+}
+/**
+ * Metrics exporters supported by Core
+ *
+ * `temporality` is the type of aggregation temporality for metric export. Applies to both Prometheus and OpenTelemetry exporters.
+ *
+ * See the [OpenTelemetry specification](https://github.com/open-telemetry/opentelemetry-specification/blob/ce50e4634efcba8da445cc23523243cb893905cb/specification/metrics/datamodel.md#temporality) for more information.
+ *
+ * @experimental
+ */
+export declare type MetricsExporter = {
+    temporality?: 'cumulative' | 'delta';
+} & (PrometheusMetricsExporter | OtelCollectorExporter);
+/**
+ * Trace exporters supported by Core
+ *
+ * @experimental
+ */
+export declare type TraceExporter = OtelCollectorExporter;
+/** @experimental */
+export interface TelemetryOptions {
+    /**
+     * A string in the env filter format specified here:
+     * https://docs.rs/tracing-subscriber/0.2.20/tracing_subscriber/struct.EnvFilter.html
+     *
+     * Which determines what tracing data is collected in the Core SDK.
+     *
+     * @deprecated Use either `logging.filter` or `tracing.filter` instead
+     */
+    tracingFilter?: string;
+    /**
+     * If set true, do not prefix metrics with `temporal_`. Will be removed eventually as
+     * the prefix is consistent with other SDKs.
+     *
+     * @default `false`
+     */
+    noTemporalPrefixForMetrics?: boolean;
+    /**
+     * Control where to send Rust Core logs
+     */
+    logging?: {
+        /**
+         * A string in (env filter format)[https://docs.rs/tracing-subscriber/0.2.20/tracing_subscriber/struct.EnvFilter.html]
+         * which determines the verboseness of logging output.
+         *
+         * You can use {@link Runtime.makeTelemetryFilterString()} to easily build a correctly formatted filter
+         * string based on desired log level for Core SDK and other native packages.
+         *
+         * **BACKWARD COMPATIBILITY**
+         *
+         * If `logging.filter` is missing, the following legacy values (if present) will be used instead (in the given order):
+         * - {@link ForwardLogger.forward.level} => `makeTelemetryFilterString({ core: level, other: level })`
+         * - {@link TelemetryOptions.tracingFilter}
+         * - Default value of `makeTelemetryFilterString({ core: 'INFO', other: 'INFO'})`
+         *
+         * @default `makeTelemetryFilterString({ core: 'INFO', other: 'INFO'})` (with some exceptions, as described in backward compatibility note above)
+         */
+        filter?: string;
+    } & Partial<Logger>;
+    /**
+     * Control where to send traces generated by Rust Core, optional and turned off by default.
+     *
+     * This is typically used for profiling SDK internals.
+     */
+    tracing?: {
+        /**
+         * A string in (env filter format)[https://docs.rs/tracing-subscriber/0.2.20/tracing_subscriber/struct.EnvFilter.html]
+         * which determines what tracing data is collected in the Core SDK.
+         *
+         * You can use {@link Runtime.makeTelemetryFilterString()} to easily build a correctly formatted filter
+         * string based on desired log level for Core SDK and other native packages.
+         *
+         * **BACKWARD COMPATIBILITY**
+         *
+         * If `tracing.filter` is missing, the following legacy values (if present) will be used instead (in the given order):
+         * - {@link TelemetryOptions.tracingFilter}
+         * - Default value of `makeTelemetryFilterString({ core: 'INFO', other: 'INFO'})`
+         *
+         * @default `makeTelemetryFilterString({ core: 'INFO', other: 'INFO'})` (with some exceptions, as described in backward compatibility note above)
+         */
+        filter?: string;
+    } & Partial<TraceExporter>;
+    /**
+     * Control exporting {@link NativeConnection} and {@link Worker} metrics.
+     *
+     * Turned off by default
+     */
+    metrics?: MetricsExporter;
+}
+/** @experimental */
+export declare type CompiledTelemetryOptions = {
+    noTemporalPrefixForMetrics?: boolean;
+    logging: {
+        filter: string;
+    } & ({
+        console: {};
+    } | {
+        forward: {};
+    });
+    tracing?: {
+        filter: string;
+    } & CompiledOtelTraceExporter;
+    metrics?: {
+        temporality?: 'cumulative' | 'delta';
+    } & (PrometheusMetricsExporter | CompiledOtelMetricsExporter);
+};
+export interface WorkerOptions {
+    /**
+     * A human-readable string that can identify your worker
+     */
+    identity: string;
+    /**
+     * A string that should be unique to the exact worker code/binary being executed
+     */
+    buildId: string;
+    /**
+     * The task queue the worker will pull from
+     */
+    taskQueue: string;
+    maxConcurrentActivityTaskExecutions: number;
+    maxConcurrentWorkflowTaskExecutions: number;
+    maxConcurrentLocalActivityExecutions: number;
+    /**
+     * If set to `false` this worker will only handle workflow tasks and local activities, it will not
+     * poll for activity tasks.
+     */
+    enableNonLocalActivities: boolean;
+    /**
+     * How long a workflow task is allowed to sit on the sticky queue before it is timed out
+     * and moved to the non-sticky queue where it may be picked up by any worker.
+     */
+    stickyQueueScheduleToStartTimeoutMs: number;
+    /**
+     * Maximum number of Workflow instances to cache before automatic eviction
+     */
+    maxCachedWorkflows: number;
+    /**
+     * Longest interval for throttling activity heartbeats
+     * @default 60 seconds
+     */
+    maxHeartbeatThrottleIntervalMs: number;
+    /**
+     * Default interval for throttling activity heartbeats in case
+     * `ActivityOptions.heartbeat_timeout` is unset.
+     * When the timeout *is* set in the `ActivityOptions`, throttling is set to
+     * `heartbeat_timeout * 0.8`.
+     * @default 30 seconds
+     */
+    defaultHeartbeatThrottleIntervalMs: number;
+    /**
+     * Sets the maximum number of activities per second the task queue will dispatch, controlled
+     * server-side. Note that this only takes effect upon an activity poll request. If multiple
+     * workers on the same queue have different values set, they will thrash with the last poller
+     * winning.
+     */
+    maxTaskQueueActivitiesPerSecond?: number;
+    /**
+     * Limits the number of activities per second that this worker will process. The worker will
+     * not poll for new activities if by doing so it might receive and execute an activity which
+     * would cause it to exceed this limit. Must be a positive floating point number.
+     */
+    maxActivitiesPerSecond?: number;
+}
+/** Log level - must match rust log level names */
+export declare type LogLevel = 'TRACE' | 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
+export interface LogEntry {
+    /** Log message */
+    message: string;
+    /**
+     * Time since epoch [seconds, nanos].
+     *
+     * Should be switched to bigint once it is supported in neon.
+     */
+    timestamp: [number, number];
+    /** Log level */
+    level: LogLevel;
+}
+/**
+ * Which version of the executable to run.
+ */
+export declare type EphemeralServerExecutable = {
+    type: 'cached-download';
+    /**
+     * Download destination directory or the system's temp directory if none set.
+     */
+    downloadDir?: string;
+    /**
+     * Optional version, can be set to a specific server release or "default" or "latest".
+     *
+     * At the time of writing the the server is released as part of the Java SDK - (https://github.com/temporalio/sdk-java/releases).
+     *
+     * @default "default" - get the best version for the current SDK version.
+     */
+    version?: string;
+} | {
+    type: 'existing-path';
+    /** Path to executable */
+    path: string;
+};
+/**
+ * Configuration for the time-skipping test server.
+ */
+export interface TimeSkippingServerConfig {
+    type: 'time-skipping';
+    executable?: EphemeralServerExecutable;
+    /**
+     * Optional port to listen on, defaults to find a random free port.
+     */
+    port?: number;
+    /**
+     * Extra args to pass to the executable command.
+     */
+    extraArgs?: string[];
+}
+/**
+ * Configuration for temporalite.
+ */
+export interface TemporaliteConfig {
+    type: 'temporalite';
+    executable?: EphemeralServerExecutable;
+    /**
+     * Namespace to use - created at startup.
+     *
+     * @default "default"
+     */
+    namespace?: string;
+    /**
+     * IP to bind to.
+     *
+     * @default 127.0.0.1
+     */
+    ip?: string;
+    /**
+     * Sqlite DB filename if persisting or non-persistent if none.
+     */
+    db_filename?: string;
+    /**
+     * Whether to enable the UI.
+     */
+    ui?: boolean;
+    /**
+     * Log format and level
+     * @default { format: "pretty", level" "warn" }
+     */
+    log?: {
+        format: string;
+        level: string;
+    };
+    /**
+     * Optional port to listen on, defaults to find a random free port.
+     */
+    port?: number;
+    /**
+     * Extra args to pass to the executable command.
+     */
+    extraArgs?: string[];
+}
+/**
+ * Configuration for spawning an ephemeral Temporal server.
+ *
+ * Both the time-skipping test server and temporalite are supported.
+ */
+export declare type EphemeralServerConfig = TimeSkippingServerConfig | TemporaliteConfig;
+export interface Worker {
+    type: 'Worker';
+}
+export interface Runtime {
+    type: 'Runtime';
+}
+export interface Client {
+    type: 'Client';
+}
+export interface EphemeralServer {
+    type: 'EphemeralServer';
+}
+export interface HistoryPusher {
+    type: 'HistoryPusher';
+}
+export interface ReplayWorker {
+    type: 'ReplayWorker';
+    worker: Worker;
+    pusher: HistoryPusher;
+}
+export declare type Callback<T> = (err: Error, result: T) => void;
+export declare type PollCallback = (err: Error, result: ArrayBuffer) => void;
+export declare type WorkerCallback = (err: Error, result: Worker) => void;
+export declare type ReplayWorkerCallback = (err: Error, worker: ReplayWorker) => void;
+export declare type ClientCallback = (err: Error, result: Client) => void;
+export declare type VoidCallback = (err: Error, result: void) => void;
+export declare type LogsCallback = (err: Error, result: LogEntry[]) => void;
+export declare function newRuntime(telemOptions: CompiledTelemetryOptions): Runtime;
+export declare function newClient(runtime: Runtime, clientOptions: ClientOptions, callback: ClientCallback): void;
+export declare function newWorker(client: Client, workerOptions: WorkerOptions, callback: WorkerCallback): void;
+export declare function newReplayWorker(runtime: Runtime, workerOptions: WorkerOptions, callback: ReplayWorkerCallback): void;
+export declare function pushHistory(pusher: HistoryPusher, workflowId: string, history: ArrayBuffer, callback: VoidCallback): void;
+export declare function closeHistoryStream(pusher: HistoryPusher): void;
+export declare function workerInitiateShutdown(worker: Worker, callback: VoidCallback): void;
+export declare function workerFinalizeShutdown(worker: Worker): void;
+export declare function clientUpdateHeaders(client: Client, headers: Record<string, string>, callback: VoidCallback): void;
+export declare function clientClose(client: Client): void;
+export declare function runtimeShutdown(runtime: Runtime, callback: VoidCallback): void;
+export declare function pollLogs(runtime: Runtime, callback: LogsCallback): void;
+export declare function workerPollWorkflowActivation(worker: Worker, spanContext: SpanContext, callback: PollCallback): void;
+export declare function workerCompleteWorkflowActivation(worker: Worker, spanContext: SpanContext, result: ArrayBuffer, callback: VoidCallback): void;
+export declare function workerPollActivityTask(worker: Worker, spanContext: SpanContext, callback: PollCallback): void;
+export declare function workerCompleteActivityTask(worker: Worker, spanContext: SpanContext, result: ArrayBuffer, callback: VoidCallback): void;
+export declare function workerRecordActivityHeartbeat(worker: Worker, heartbeat: ArrayBuffer): void;
+export declare function getTimeOfDay(): [number, number];
+export declare function startEphemeralServer(runtime: Runtime, config: EphemeralServerConfig, sdkVersion: string, callback: Callback<EphemeralServer>): void;
+export declare function shutdownEphemeralServer(server: EphemeralServer, callback: Callback<EphemeralServer>): void;
+export declare function getEphemeralServerTarget(server: EphemeralServer): string;
+export { ShutdownError, TransportError, UnexpectedError } from './errors';

package/lib/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnexpectedError = exports.TransportError = exports.ShutdownError = void 0;
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "ShutdownError", { enumerable: true, get: function () { return errors_1.ShutdownError; } });
+Object.defineProperty(exports, "TransportError", { enumerable: true, get: function () { return errors_1.TransportError; } });
+Object.defineProperty(exports, "UnexpectedError", { enumerable: true, get: function () { return errors_1.UnexpectedError; } });
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":";;;AAigBA,mCAA0E;AAAjE,uGAAA,aAAa,OAAA;AAAE,wGAAA,cAAc,OAAA;AAAE,yGAAA,eAAe,OAAA"}

package/package.json

@@ -1,14 +1,17 @@
 {
   "name": "@temporalio/core-bridge",
-  "version": "1.4.3",
+  "version": "1.5.0",
   "description": "Temporal.io SDK Core<>Node bridge",
   "main": "index.js",
-  "types": "index.d.ts",
+  "types": "lib/index.d.ts",
   "scripts": {
     "build-rust": "node ./scripts/build.js --force",
     "build": "npm run build-rust",
     "build-rust-release": "npm run build-rust -- --release",
-    "install": "node ./scripts/build.js"
+    "install": "node ./scripts/build.js",
+    "format": "cargo fmt",
+    "lint": "cargo clippy --fix",
+    "lint.check": "cargo clippy"
   },
   "keywords": [
     "temporal",
@@ -20,6 +23,7 @@
   "license": "MIT",
   "dependencies": {
     "@opentelemetry/api": "^1.1.0",
+    "@temporalio/common": "~1.5.0",
     "arg": "^5.0.2",
     "cargo-cp-artifact": "^0.1.6",
     "which": "^2.0.2"
@@ -37,10 +41,12 @@
     "Cargo.lock",
     "index.js",
     "common.js",
-    "index.d.ts"
+    "index.d.ts",
+    "ts",
+    "lib"
   ],
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "be51cfac7016b66151d70dbd5aca7f7ef02b260a"
+  "gitHead": "b46426d8b9b342c052d53520b50dbb991b8d5e03"
 }

package/sdk-core/.buildkite/docker/Dockerfile

@@ -1,4 +1,4 @@
-FROM rust:1.63
+FROM rust:1.65
 
 RUN rustup component add rustfmt && \
 	rustup component add clippy

package/sdk-core/.buildkite/docker/docker-compose.yaml

@@ -9,7 +9,7 @@ services:
   #      - '9042:9042'
 
   temporal:
-    image: temporalio/auto-setup:1.16.2
+    image: temporalio/auto-setup:1.18.3
     ports:
       - "7233:7233"
       - "7234:7234"
@@ -28,7 +28,7 @@ services:
       - cassandra
 
   temporal-web:
-    image: temporalio/ui:0.10.2
+    image: temporalio/ui:2.8.0
     logging:
       driver: none
     ports: