@stigmer/runner-slim-darwin-arm64 3.0.8-dev.20260612062921

package/README.md

@@ -0,0 +1,3 @@
+# @stigmer/runner-slim-darwin-arm64
+
+Platform support package for [@stigmer/runner-slim](https://www.npmjs.com/package/@stigmer/runner-slim). Contains [@temporalio/core-bridge](https://www.npmjs.com/package/@temporalio/core-bridge) 1.16.2 (MIT) pruned to the aarch64-apple-darwin prebuilt release. Installed automatically on darwin/arm64; never depend on it directly.

package/core-bridge/README.md

@@ -0,0 +1,9 @@
+# `@temporalio/core-bridge`
+
+[![NPM](https://img.shields.io/npm/v/@temporalio/core-bridge?style=for-the-badge)](https://www.npmjs.com/package/@temporalio/core-bridge)
+
+Part of [Temporal](https://temporal.io)'s [TypeScript SDK](https://docs.temporal.io/typescript/introduction/).
+
+> [!CAUTION]
+> This package is not intended to be used directly. Any API provided
+> by this package is internal and subject to change without notice.

package/core-bridge/common.js

@@ -0,0 +1,53 @@
+/**
+ * Shared code for scripts/build.js and index.js
+ *
+ * @module
+ */
+
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+
+// List of tested compile targets
+const targets = [
+  'x86_64-apple-darwin',
+  'aarch64-apple-darwin',
+  'x86_64-unknown-linux-gnu',
+  'aarch64-unknown-linux-gnu',
+  // TODO: this is not supported on macos
+  'x86_64-pc-windows-msvc',
+  'x86_64-pc-windows-gnu',
+];
+
+const archAlias = { x64: 'x86_64', arm64: 'aarch64' };
+const platformMapping = { darwin: 'apple-darwin', linux: 'unknown-linux-gnu', win32: 'pc-windows-msvc' };
+
+class PrebuildError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'PrebuildError';
+  }
+}
+
+function getPrebuiltTargetName() {
+  const arch = archAlias[os.arch()];
+  if (arch === undefined) {
+    throw new PrebuildError(`No prebuilt module for arch ${os.arch()}`);
+  }
+  const platform = platformMapping[os.platform()];
+  if (platform === undefined) {
+    throw new PrebuildError(`No prebuilt module for platform ${os.platform()}`);
+  }
+  return `${arch}-${platform}`;
+}
+
+function getPrebuiltPath() {
+  const binary = path.resolve(__dirname, 'releases', getPrebuiltTargetName(), 'index.node');
+  if (fs.existsSync(binary)) {
+    return binary;
+  } else {
+    throw new PrebuildError(`No prebuilt module found at ${binary}`);
+  }
+}
+
+module.exports = { targets, archAlias, platformMapping, PrebuildError, getPrebuiltPath, getPrebuiltTargetName };

package/core-bridge/index.js

@@ -0,0 +1,92 @@
+const { isPromise } = require('node:util/types');
+const { getPrebuiltPath } = require('./common');
+const typescriptExports = require('./lib/index');
+const { convertFromNamedError } = require('./lib/errors');
+
+/**
+ * Wraps calls to native functions to convert "named errors" to the correct error types.
+ */
+function wrapErrors(fn) {
+  return (...args) => {
+    try {
+      let res = fn(...args);
+      if (isPromise(res)) {
+        return res.catch((e) => {
+          throw convertFromNamedError(e, false);
+        });
+      }
+      return res;
+    } catch (e) {
+      throw convertFromNamedError(e, true);
+    }
+  };
+}
+let wrapper = (f) => wrapErrors(f);
+
+/**
+ * Wraps calls to native functions to add tracing logs.
+ *
+ * To enable, set the `TEMPORAL_TRACE_NATIVE_CALLS` environment variable to `true`.
+ *
+ * IMPORTANT: This is meant for internal SDK debugging only.
+ */
+if (process.env.TEMPORAL_TRACE_NATIVE_CALLS?.toLowerCase() === 'true') {
+  // Generate a random 5-character ID for the current "execution"
+  let execId = Math.random().toString(36).slice(-5);
+  let callSequence = 100000;
+
+  function log(callid, msg) {
+    console.log(`${new Date().toISOString()} [call-to-bridge] ${callid} ${msg}`);
+  }
+
+  // Do not trace these functions, they are way too verbose
+  const ignoreList = ['get_time_of_day'];
+
+  function wrapDebug(fn, fnname) {
+    // Functions names looks like `temporal_sdk_typescript_bridge::logs::get_time_of_day`
+    // Strip the path to retain only the function name
+    fnname = fnname.substring(fnname.lastIndexOf('::') + 2);
+    if (ignoreList.includes(fnname)) return fn;
+
+    return (...args) => {
+      let callid = `${execId}:${String(callSequence++).slice(-5)}`;
+
+      try {
+        log(callid, `${fnname}() - calling in`);
+
+        let res = fn(...args);
+
+        if (isPromise(res)) {
+          log(callid, `${fnname}() - received promise`);
+          return res.then(
+            (x) => {
+              log(callid, `${fnname}() - promise resolved`);
+              return x;
+            },
+            (e) => {
+              log(callid, `${fnname}() - promise rejected with ${e}`);
+              throw convertFromNamedError(e, false);
+            }
+          );
+        } else {
+          log(callid, `${fnname}() - returned`);
+        }
+
+        return res;
+      } catch (e) {
+        log(callid, `${fnname}() - threw an error ${e}`);
+        throw convertFromNamedError(e, true);
+      }
+    };
+  }
+
+  wrapper = (f) => wrapDebug(wrapErrors(f), f.name);
+}
+
+try {
+  const nativeLibPath = getPrebuiltPath();
+  const native = Object.fromEntries(Object.entries(require(nativeLibPath)).map(([name, fn]) => [name, wrapper(fn)]));
+  module.exports = { ...typescriptExports, native };
+} catch (err) {
+  throw err;
+}

package/core-bridge/lib/errors.d.ts

@@ -0,0 +1,46 @@
+import * as grpc from '@grpc/grpc-js';
+import { IllegalStateError } from '@temporalio/common';
+/**
+ * The worker has been shut down
+ */
+export declare class ShutdownError extends Error {
+}
+/**
+ * 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 {
+}
+/**
+ * Something unexpected happened, considered fatal
+ */
+export declare class UnexpectedError extends Error {
+    cause?: unknown;
+    constructor(message: string, cause?: unknown);
+}
+export interface NativeServiceError {
+    name: 'ServiceError';
+    message: string;
+    code: number;
+    details: string;
+    metadata: Record<string, Buffer | string>;
+    stack?: string;
+}
+/**
+ * A gRPC call failed. The error carries the gRPC status code, message, and other details.
+ */
+export declare class ServiceError extends Error implements grpc.ServiceError {
+    readonly code: grpc.StatusObject['code'];
+    readonly details: string;
+    readonly metadata: grpc.Metadata;
+    constructor(message: string, code: grpc.StatusObject['code'], details: string, metadata: grpc.Metadata);
+    static fromNative(err: NativeServiceError): ServiceError;
+}
+/**
+ * Something unexpected happened, considered fatal
+ */
+export declare class NativePromiseDroppedError extends UnexpectedError {
+    constructor(message: string);
+}
+export { IllegalStateError };
+export declare function convertFromNamedError(e: unknown, keepStackTrace: boolean): unknown;

package/core-bridge/lib/errors.js

@@ -0,0 +1,149 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var ServiceError_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IllegalStateError = exports.NativePromiseDroppedError = exports.ServiceError = exports.UnexpectedError = exports.TransportError = exports.ShutdownError = void 0;
+exports.convertFromNamedError = convertFromNamedError;
+const grpc = __importStar(require("@grpc/grpc-js"));
+const common_1 = require("@temporalio/common");
+Object.defineProperty(exports, "IllegalStateError", { enumerable: true, get: function () { return common_1.IllegalStateError; } });
+const type_helpers_1 = require("@temporalio/common/lib/type-helpers");
+/**
+ * The worker has been shut down
+ */
+let ShutdownError = class ShutdownError extends Error {
+};
+exports.ShutdownError = ShutdownError;
+exports.ShutdownError = ShutdownError = __decorate([
+    (0, type_helpers_1.SymbolBasedInstanceOfError)('ShutdownError')
+], ShutdownError);
+/**
+ * Thrown after shutdown was requested as a response to a poll function, JS should stop polling
+ * once this error is encountered
+ */
+let TransportError = class TransportError extends Error {
+};
+exports.TransportError = TransportError;
+exports.TransportError = TransportError = __decorate([
+    (0, type_helpers_1.SymbolBasedInstanceOfError)('TransportError')
+], TransportError);
+/**
+ * Something unexpected happened, considered fatal
+ */
+let UnexpectedError = class UnexpectedError extends Error {
+    cause;
+    constructor(message, cause) {
+        super(message);
+        this.cause = cause;
+    }
+};
+exports.UnexpectedError = UnexpectedError;
+exports.UnexpectedError = UnexpectedError = __decorate([
+    (0, type_helpers_1.SymbolBasedInstanceOfError)('UnexpectedError')
+], UnexpectedError);
+/**
+ * A gRPC call failed. The error carries the gRPC status code, message, and other details.
+ */
+let ServiceError = ServiceError_1 = class ServiceError extends Error {
+    code;
+    details;
+    metadata;
+    constructor(message, code, details, metadata) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.metadata = metadata;
+    }
+    static fromNative(err) {
+        const metadata = new grpc.Metadata();
+        for (const [k, v] of Object.entries(err.metadata ?? {})) {
+            metadata.set(k, v);
+        }
+        return new ServiceError_1(err.message, err.code ?? 0, err.details ?? '', metadata);
+    }
+};
+exports.ServiceError = ServiceError;
+exports.ServiceError = ServiceError = ServiceError_1 = __decorate([
+    (0, type_helpers_1.SymbolBasedInstanceOfError)('ServiceError')
+], ServiceError);
+/**
+ * Something unexpected happened, considered fatal
+ */
+let NativePromiseDroppedError = class NativePromiseDroppedError extends UnexpectedError {
+    constructor(message) {
+        super(message);
+    }
+};
+exports.NativePromiseDroppedError = NativePromiseDroppedError;
+exports.NativePromiseDroppedError = NativePromiseDroppedError = __decorate([
+    (0, type_helpers_1.SymbolBasedInstanceOfError)('NativePromiseDroppedError')
+], NativePromiseDroppedError);
+// Check if the error's class is exactly Error (not a descendant of it), in a realm-safe way
+function isBareError(e) {
+    return (0, type_helpers_1.isError)(e) && Object.getPrototypeOf(e)?.name === 'Error';
+}
+function convertFromNamedError(e, keepStackTrace) {
+    if (isBareError(e)) {
+        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, e);
+                newerr.stack = keepStackTrace ? e.stack : undefined;
+                return newerr;
+            case 'ServiceError':
+                newerr = ServiceError.fromNative(e);
+                newerr.stack = keepStackTrace ? e.stack : undefined;
+                return newerr;
+        }
+        // Neon ensures that dropping an unsettled Promise results in a rejection, which is
+        // much better than just hanging the JS process. Sad though that it does so with an
+        // error message that would mean nothing to a user.
+        if (e.message === '`neon::types::Deferred` was dropped without being settled') {
+            newerr = new NativePromiseDroppedError('Native Promise was dropped without being settled');
+            newerr.stack = keepStackTrace ? e.stack : undefined;
+            return newerr;
+        }
+    }
+    return e;
+}
+//# sourceMappingURL=errors.js.map

package/core-bridge/lib/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../ts/errors.ts"],"names":[],"mappings":"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"}

package/core-bridge/lib/index.d.ts

@@ -0,0 +1,15 @@
+import * as native from './native';
+import * as errors from './errors';
+export { 
+/**
+ * @internal This module is not intended to be used directly. Any API provided
+ *           by this package is internal and subject to change without notice.
+ * @hidden
+ */
+native, 
+/**
+ * @internal This module is not intended to be used directly. Any API provided
+ *           by this package is internal and subject to change without notice.
+ * @hidden
+ */
+errors, };

package/core-bridge/lib/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.errors = exports.native = void 0;
+const native = __importStar(require("./native"));
+exports.native = native;
+const errors = __importStar(require("./errors"));
+exports.errors = errors;
+//# sourceMappingURL=index.js.map

package/core-bridge/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,iDAAmC;AASjC,wBAAM;AARR,iDAAmC;AAejC,wBAAM"}

package/core-bridge/lib/native.d.ts

@@ -0,0 +1,372 @@
+/**
+ * Indicates a property that is allowed to be unspecified when calling in or out of
+ * native code (the equivalent of the `Option<T>` type in Rust).
+ *
+ * Always use either this type or the `T | null` idiom to indicate a property that may
+ * legitimately be left unspecified when calling into or out of native code. Never use
+ * `T | undefined` or `prop?: T` on TS/Rust interfaces.
+ *
+ * ### Rationale
+ *
+ * Differentiating between "a property that is set to an unspecified optional value"
+ * and "a non-existant property" allows eager detection of some of the most common
+ * bug patterns resulting from incoherencies between the JS and Rust type definitions
+ * (e.g. optional properties whose names differ between the two languages, or that
+ * are missing in the JS interface, etc.).
+ *
+ * Unfortunately, it is not possible at present in Neon to differentiate between
+ * a property that is set to `undefined` and a property that is missing;
+ * i.e. `obj.get_value(cx, "prop")` will return `undefined` in both cases.
+ *
+ * We therefore follow the following principles for our TypeScript/Rust interfaces:
+ *
+ * - Always use `null` to indicate an intentionally unspecified optional value
+ *   in TypeScript interfaces. This will be converted to `None` on the Rust side.
+ * - Explicitly set _every_ properties on objects sent to the native code,
+ *   including optional properties (e.g. `{ prop: input.prop ?? null }`).
+ * - Never use the "optional property" syntax in TypeScript (i.e. `prop?: T`).
+ *
+ * Thanks to those conventions, a property that reads as `undefined` is known to to always
+ * indicate an _unintentionally missing_ property, which will results in a runtime error.
+ */
+type Option<T> = T | null;
+/**
+ * Marker for values that are transferred as JSON strings.
+ */
+export type JsonString<_T> = string;
+export declare function newRuntime(runtimeOptions: RuntimeOptions): Runtime;
+export declare function runtimeShutdown(runtime: Runtime): void;
+export interface Runtime {
+    type: 'runtime';
+}
+export type RuntimeOptions = {
+    logExporter: LogExporterOptions;
+    telemetry: TelemetryOptions;
+    metricsExporter: MetricExporterOptions;
+    workerHeartbeatIntervalMillis: Option<number>;
+};
+export type TelemetryOptions = {
+    attachServiceName: boolean;
+    metricPrefix: string;
+};
+export type LogExporterOptions = {
+    type: 'console';
+    filter: string;
+} | {
+    type: 'forward';
+    filter: string;
+    receiver: (entries: JsonString<LogEntry>[]) => void;
+};
+export type MetricExporterOptions = PrometheusMetricsExporterOptions | OtelMetricsExporterOptions | BufferedMetricsExporterOptions | null;
+export interface PrometheusMetricsExporterOptions {
+    type: 'prometheus';
+    socketAddr: string;
+    globalTags: Record<string, string>;
+    countersTotalSuffix: boolean;
+    unitSuffix: boolean;
+    useSecondsForDurations: boolean;
+    histogramBucketOverrides: Record<string, number[]>;
+}
+export interface OtelMetricsExporterOptions {
+    type: 'otel';
+    url: string;
+    headers: Record<string, string>;
+    metricPeriodicity: number;
+    metricTemporality: 'cumulative' | 'delta';
+    globalTags: Record<string, string>;
+    useSecondsForDurations: boolean;
+    histogramBucketOverrides: Record<string, number[]>;
+    protocol: 'http' | 'grpc';
+}
+export interface BufferedMetricsExporterOptions {
+    type: 'buffer';
+    maxBufferSize: number;
+    useSecondsForDurations: boolean;
+}
+export declare function newClient(runtime: Runtime, clientOptions: ClientOptions): Promise<Client>;
+export declare function clientUpdateHeaders(client: Client, headers: Record<string, MetadataValue>): void;
+export declare function clientUpdateApiKey(client: Client, apiKey: string): void;
+export declare function clientSendWorkflowServiceRequest(client: Client, call: RpcCall): Promise<Buffer>;
+export declare function clientSendOperatorServiceRequest(client: Client, call: RpcCall): Promise<Buffer>;
+export declare function clientSendTestServiceRequest(client: Client, call: RpcCall): Promise<Buffer>;
+export declare function clientSendHealthServiceRequest(client: Client, call: RpcCall): Promise<Buffer>;
+export declare function clientClose(client: Client): void;
+export interface Client {
+    type: 'client';
+}
+export interface ClientOptions {
+    targetUrl: string;
+    clientName: string;
+    clientVersion: string;
+    tls: Option<TlsOptions>;
+    httpConnectProxy: Option<HttpConnectProxy>;
+    headers: Option<Record<string, MetadataValue>>;
+    apiKey: Option<string>;
+    disableErrorCodeMetricTags: boolean;
+}
+export interface TlsOptions {
+    domain: Option<string>;
+    serverRootCaCert: Option<Buffer>;
+    clientTlsOptions: Option<TlsOptionsClientCertPair>;
+}
+export interface TlsOptionsClientCertPair {
+    clientCert: Buffer;
+    clientPrivateKey: Buffer;
+}
+export interface HttpConnectProxy {
+    targetHost: string;
+    basicAuth: Option<{
+        username: string;
+        password: string;
+    }>;
+}
+export interface HttpConnectProxyBasicAuth {
+    username: string;
+    password: string;
+}
+export interface RpcCall {
+    rpc: string;
+    req: Buffer;
+    retry: boolean;
+    metadata: Record<string, MetadataValue>;
+    timeout: Option<number>;
+}
+export declare function newWorker(client: Client, workerOptions: WorkerOptions): Worker;
+export declare function workerValidate(worker: Worker): Promise<Buffer>;
+export declare function workerPollWorkflowActivation(worker: Worker): Promise<Buffer>;
+export declare function workerCompleteWorkflowActivation(worker: Worker, result: Buffer): Promise<void>;
+export declare function workerPollActivityTask(worker: Worker): Promise<Buffer>;
+export declare function workerCompleteActivityTask(worker: Worker, result: Buffer): Promise<void>;
+export declare function workerRecordActivityHeartbeat(worker: Worker, heartbeat: Buffer): void;
+export declare function workerPollNexusTask(worker: Worker): Promise<Buffer>;
+export declare function workerCompleteNexusTask(worker: Worker, result: Buffer): Promise<void>;
+export declare function workerInitiateShutdown(worker: Worker): void;
+export declare function workerFinalizeShutdown(worker: Worker): Promise<void>;
+export declare function workerReplaceClient(worker: Worker, client: Client): void;
+export interface Worker {
+    type: 'worker';
+}
+export type MetadataValue = {
+    type: 'ascii';
+    value: string;
+} | {
+    type: 'binary';
+    value: Buffer;
+};
+export interface WorkerOptions {
+    identity: string;
+    buildId: string;
+    useVersioning: boolean;
+    workerDeploymentOptions: Option<WorkerDeploymentOptions>;
+    taskQueue: string;
+    namespace: string;
+    tuner: WorkerTunerOptions;
+    nonStickyToStickyPollRatio: number;
+    workflowTaskPollerBehavior: PollerBehavior;
+    activityTaskPollerBehavior: PollerBehavior;
+    nexusTaskPollerBehavior: PollerBehavior;
+    taskTypes: {
+        enableWorkflows: boolean;
+        enableLocalActivities: boolean;
+        enableRemoteActivities: boolean;
+        enableNexus: boolean;
+    };
+    stickyQueueScheduleToStartTimeout: number;
+    maxCachedWorkflows: number;
+    maxHeartbeatThrottleInterval: number;
+    defaultHeartbeatThrottleInterval: number;
+    maxTaskQueueActivitiesPerSecond: Option<number>;
+    maxActivitiesPerSecond: Option<number>;
+    shutdownGraceTime: number;
+    plugins: string[];
+}
+export type PollerBehavior = {
+    type: 'simple-maximum';
+    maximum: number;
+} | {
+    type: 'autoscaling';
+    minimum: number;
+    maximum: number;
+    initial: number;
+};
+export type WorkerDeploymentOptions = {
+    version: WorkerDeploymentVersion;
+    useWorkerVersioning: boolean;
+    defaultVersioningBehavior: Option<VersioningBehavior>;
+};
+export type WorkerDeploymentVersion = {
+    buildId: string;
+    deploymentName: string;
+};
+export type VersioningBehavior = {
+    type: 'pinned';
+} | {
+    type: 'auto-upgrade';
+};
+export interface WorkerTunerOptions {
+    workflowTaskSlotSupplier: SlotSupplierOptions;
+    activityTaskSlotSupplier: SlotSupplierOptions;
+    localActivityTaskSlotSupplier: SlotSupplierOptions;
+    nexusTaskSlotSupplier: SlotSupplierOptions;
+}
+export type SlotSupplierOptions = FixedSizeSlotSupplierOptions | ResourceBasedSlotSupplierOptions | CustomSlotSupplierOptions<any>;
+interface FixedSizeSlotSupplierOptions {
+    type: 'fixed-size';
+    numSlots: number;
+}
+interface ResourceBasedSlotSupplierOptions {
+    type: 'resource-based';
+    minimumSlots: number;
+    maximumSlots: number;
+    rampThrottle: number;
+    tunerOptions: ResourceBasedTunerOptions;
+}
+interface ResourceBasedTunerOptions {
+    targetMemoryUsage: number;
+    targetCpuUsage: number;
+}
+export interface CustomSlotSupplierOptions<SI extends SlotInfo> {
+    type: 'custom';
+    reserveSlot(ctx: SlotReserveContext, abortSignal: AbortSignal): Promise<SlotPermit>;
+    tryReserveSlot(ctx: SlotReserveContext): Option<SlotPermit>;
+    markSlotUsed(ctx: SlotMarkUsedContext<SI>): void;
+    releaseSlot(ctx: SlotReleaseContext<SI>): void;
+}
+export type SlotInfo = {
+    type: 'workflow';
+    workflowType: string;
+    isSticky: boolean;
+} | {
+    type: 'activity';
+    activityType: string;
+} | {
+    type: 'local-activity';
+    activityType: string;
+} | {
+    type: 'nexus';
+    service: string;
+    operation: string;
+};
+export interface SlotReserveContext {
+    slotType: SlotInfo['type'];
+    taskQueue: string;
+    workerIdentity: string;
+    workerDeploymentVersion: Option<WorkerDeploymentVersion>;
+    isSticky: boolean;
+}
+export interface SlotMarkUsedContext<SI extends SlotInfo> {
+    slotInfo: SI;
+    permit: SlotPermit;
+}
+export interface SlotReleaseContext<SI extends SlotInfo> {
+    slotInfo: Option<SI>;
+    permit: SlotPermit;
+}
+export interface SlotPermit {
+}
+export declare function newReplayWorker(runtime: Runtime, workerOptions: WorkerOptions): [Worker, HistoryPusher];
+export declare function pushHistory(pusher: HistoryPusher, workflowId: string, history: Buffer): Promise<void>;
+export declare function closeHistoryStream(pusher: HistoryPusher): void;
+export interface HistoryPusher {
+    type: 'history-pusher';
+}
+export declare function newEphemeralServer(runtime: Runtime, config: EphemeralServerConfig): Promise<EphemeralServer>;
+export declare function ephemeralServerGetTarget(server: EphemeralServer): string;
+export declare function ephemeralServerShutdown(server: EphemeralServer): Promise<void>;
+export interface EphemeralServer {
+    type: 'ephemeral-server';
+}
+export type EphemeralServerConfig = TimeSkippingServerConfig | DevServerConfig;
+export interface TimeSkippingServerConfig {
+    type: 'time-skipping';
+    exe: EphemeralServerExecutableConfig;
+    port: Option<number>;
+    extraArgs: string[];
+}
+export interface DevServerConfig {
+    type: 'dev-server';
+    exe: EphemeralServerExecutableConfig;
+    namespace: string;
+    ip: string;
+    port: Option<number>;
+    uiPort: Option<number>;
+    dbFilename: Option<string>;
+    ui: boolean;
+    log: DevServerLogConfig;
+    extraArgs: string[];
+}
+export interface DevServerLogConfig {
+    format: string;
+    level: string;
+}
+export type EphemeralServerExecutableConfig = CachedDownloadConfig | ExistingPathConfig;
+export interface CachedDownloadConfig {
+    type: 'cached-download';
+    downloadDir: Option<string>;
+    version: string;
+    ttl: number;
+    sdkName: string;
+    sdkVersion: string;
+}
+export interface ExistingPathConfig {
+    type: 'existing-path';
+    path: string;
+}
+export declare function getTimeOfDay(): bigint;
+export interface LogEntry {
+    target: string;
+    message: string;
+    timestamp: string;
+    level: LogLevel;
+    fields: LogEntryMetadata;
+    spanContexts: string[];
+}
+type LogLevel = 'TRACE' | 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
+type LogEntryMetadata = {
+    [key: string]: string | number | boolean | LogEntryMetadata;
+};
+export interface MetricMeter {
+    type: 'metric-meter';
+}
+export interface MetricCounter {
+    type: 'metric-counter';
+}
+export interface MetricHistogram {
+    type: 'metric-histogram';
+}
+export interface MetricHistogramF64 {
+    type: 'metric-histogram-f64';
+}
+export interface MetricGauge {
+    type: 'metric-gauge';
+}
+export interface MetricGaugeF64 {
+    type: 'metric-gauge-f64';
+}
+export type MetricAttributes = Record<string, string | number | boolean>;
+export declare function newMetricCounter(runtime: Runtime, name: string, unit: string, description: string): MetricCounter;
+export declare function newMetricHistogram(runtime: Runtime, name: string, unit: string, description: string): MetricHistogram;
+export declare function newMetricHistogramF64(runtime: Runtime, name: string, unit: string, description: string): MetricHistogramF64;
+export declare function newMetricGauge(runtime: Runtime, name: string, unit: string, description: string): MetricGauge;
+export declare function newMetricGaugeF64(runtime: Runtime, name: string, unit: string, description: string): MetricGaugeF64;
+export declare function addMetricCounterValue(counter: MetricCounter, value: number, attrs: JsonString<MetricAttributes>): void;
+export declare function recordMetricHistogramValue(histogram: MetricHistogram, value: number, attrs: JsonString<MetricAttributes>): void;
+export declare function recordMetricHistogramF64Value(histogram: MetricHistogramF64, value: number, attrs: JsonString<MetricAttributes>): void;
+export declare function setMetricGaugeValue(gauge: MetricGauge, value: number, attrs: JsonString<MetricAttributes>): void;
+export declare function setMetricGaugeF64Value(gauge: MetricGaugeF64, value: number, attrs: JsonString<MetricAttributes>): void;
+export declare function runtimeRetrieveBufferedMetrics(runtime: Runtime): BufferedMetricUpdate[];
+export interface BufferedMetricUpdate {
+    metric: BufferedMetric;
+    value: number;
+    attributes: MetricAttributes;
+}
+export interface BufferedMetric {
+    name: string;
+    description: string;
+    unit: string;
+    kind: BufferedMetricKind;
+    valueType: BufferedMetricValueType;
+}
+export type BufferedMetricKind = 'counter' | 'histogram' | 'gauge';
+export type BufferedMetricValueType = 'int' | 'float';
+export {};

package/core-bridge/lib/native.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=native.js.map

package/core-bridge/lib/native.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native.js","sourceRoot":"","sources":["../ts/native.ts"],"names":[],"mappings":""}

package/core-bridge/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@temporalio/core-bridge",
+  "version": "1.16.2",
+  "description": "Temporal.io SDK Core<>Node bridge",
+  "main": "index.js",
+  "types": "lib/index.d.ts",
+  "keywords": [
+    "temporal",
+    "workflow",
+    "core",
+    "worker"
+  ],
+  "author": "Temporal Technologies Inc. <sdk@temporal.io>",
+  "license": "MIT",
+  "dependencies": {
+    "@grpc/grpc-js": "^1.12.4",
+    "@temporalio/common": "1.16.2"
+  },
+  "devDependencies": {
+    "arg": "^5.0.2",
+    "cargo-cp-artifact": "^0.1.9",
+    "tsx": "^4.20.6"
+  },
+  "bugs": {
+    "url": "https://github.com/temporalio/sdk-typescript/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/temporalio/sdk-typescript.git",
+    "directory": "packages/core-bridge"
+  },
+  "homepage": "https://github.com/temporalio/sdk-typescript/tree/main/packages/core-bridge",
+  "engines": {
+    "node": ">= 20.0.0"
+  },
+  "files": [
+    "bridge-macros",
+    "scripts",
+    "src",
+    "releases",
+    "sdk-core",
+    "Cargo.toml",
+    "Cargo.lock",
+    "index.js",
+    "common.js",
+    "index.d.ts",
+    "ts",
+    "lib"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build-rust": "tsx ./scripts/build.ts --force",
+    "build": "pnpm run build-rust",
+    "build-rust-release": "pnpm run build-rust --release",
+    "format": "cargo fmt",
+    "lint": "cargo clippy --fix --allow-staged",
+    "lint:check": "cargo clippy"
+  }
+}

package/index.cjs

@@ -0,0 +1,4 @@
+// Re-exports the vendored @temporalio/core-bridge (MIT), pruned to the
+// aarch64-apple-darwin prebuilt release. Loaded via @stigmer/runner-slim's
+// core-bridge shim — never import this package directly.
+module.exports = require("./core-bridge/index.js");

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@stigmer/runner-slim-darwin-arm64",
+  "version": "3.0.8-dev.20260612062921",
+  "description": "Temporal native bridge for the slim Stigmer runner (darwin-arm64)",
+  "license": "MIT",
+  "main": "index.cjs",
+  "os": [
+    "darwin"
+  ],
+  "cpu": [
+    "arm64"
+  ],
+  "dependencies": {
+    "@temporalio/common": "1.16.2",
+    "@grpc/grpc-js": "^1.12.4"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/stigmer/stigmer.git",
+    "directory": "backend/services/runner"
+  }
+}