@proompteng/temporal-bun-sdk 0.1.0

package/dist/src/internal/core-bridge/native.js

@@ -0,0 +1,1208 @@
+import { dlopen, FFIType, JSCallback, ptr, toArrayBuffer } from 'bun:ffi';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const moduleDir = dirname(fileURLToPath(import.meta.url));
+const packageRoot = resolvePackageRoot();
+const distNativeDir = join(packageRoot, 'dist', 'native');
+const zigStageLibDir = join(packageRoot, 'bruke', 'zig-out', 'lib');
+const UNKNOWN_NATIVE_ERROR_CODE = 2;
+export class NativeBridgeError extends Error {
+    code;
+    details;
+    raw;
+    constructor(input) {
+        const payload = typeof input === 'string'
+            ? { code: UNKNOWN_NATIVE_ERROR_CODE, message: input, raw: input }
+            : {
+                code: input.code ?? UNKNOWN_NATIVE_ERROR_CODE,
+                message: input.message ?? 'Unknown native error',
+                details: input.details,
+                raw: input.raw ?? input.message,
+            };
+        const message = payload.message ?? 'Unknown native error';
+        super(message);
+        this.name = 'NativeBridgeError';
+        this.code = payload.code;
+        this.details = payload.details;
+        this.raw = payload.raw ?? message;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+const nativeLogLevels = ['trace', 'debug', 'info', 'warn', 'error'];
+const utf8Decoder = new TextDecoder('utf-8');
+const runtimeLoggerState = new Map();
+const runtimeTelemetryState = new Map();
+const byteArrayMetricsState = {
+    totalAllocations: 0,
+    totalFrees: 0,
+    activeBuffers: 0,
+    doubleFreePreventions: 0,
+};
+const byteArrayActivePointers = new Set();
+const decodeUtf8 = (pointer, length) => {
+    if (!pointer || length === 0)
+        return '';
+    return utf8Decoder.decode(new Uint8Array(toArrayBuffer(pointer, length)));
+};
+const pointerFromBuffer = (buffer) => {
+    if (!buffer || buffer.length === 0) {
+        return 0;
+    }
+    return ptr(buffer);
+};
+const mapLogLevel = (levelIndex) => {
+    const value = nativeLogLevels[levelIndex];
+    return value ?? 'info';
+};
+const parseFields = (json) => {
+    if (!json || json.length === 0) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return undefined;
+    }
+};
+const detachLoggerOrThrow = (runtime) => {
+    const status = Number(temporal_bun_runtime_set_logger(runtime.handle, 0));
+    if (status !== 0) {
+        throw buildNativeBridgeError();
+    }
+    const handleId = Number(runtime.handle);
+    const registration = runtimeLoggerState.get(handleId);
+    if (registration) {
+        runtimeLoggerState.delete(handleId);
+        try {
+            registration.onDetach?.();
+        }
+        catch { }
+        registration.jsCallback.close();
+    }
+};
+const detachLoggerUnsafe = (runtime) => {
+    try {
+        detachLoggerOrThrow(runtime);
+    }
+    catch { }
+};
+function loadBridgeLibrary() {
+    const symbolMap = buildBridgeSymbolMap();
+    const override = process.env.TEMPORAL_BUN_SDK_NATIVE_PATH;
+    if (override) {
+        if (!existsSync(override)) {
+            throw new Error(`Temporal Bun bridge override not found at ${override}`);
+        }
+        ensureZigBridgePath(override);
+        try {
+            return {
+                module: dlopen(override, symbolMap),
+                path: override,
+                variant: 'zig',
+            };
+        }
+        catch (error) {
+            throw buildBridgeLoadError(override, error, {
+                variant: 'zig',
+                preference: 'enable',
+                override: true,
+            });
+        }
+    }
+    const preference = getZigPreference();
+    if (preference === 'disable') {
+        throw new NativeBridgeError('TEMPORAL_BUN_SDK_USE_ZIG=0 is no longer supported. The Rust bridge has been removed; build the Zig bridge with "pnpm --filter @proompteng/temporal-bun-sdk run build:native:zig" instead.');
+    }
+    const candidates = resolveBridgeLibraryCandidates(preference);
+    if (candidates.length === 0) {
+        throw new NativeBridgeError('No Zig bridge artefacts were found. Run "pnpm --filter @proompteng/temporal-bun-sdk run build:native:zig" to compile the bridge, or publish prebuilt artefacts alongside the package.');
+    }
+    let lastError = null;
+    let lastCandidate = null;
+    for (const candidate of candidates) {
+        let candidatePath;
+        try {
+            candidatePath = candidate.resolvePath();
+        }
+        catch (error) {
+            lastError = error;
+            logZigBridgeLoadFailure('(failed to resolve Zig bridge path)', error);
+            continue;
+        }
+        try {
+            return {
+                module: dlopen(candidatePath, symbolMap),
+                path: candidatePath,
+                variant: candidate.variant,
+            };
+        }
+        catch (error) {
+            lastError = error;
+            lastCandidate = { path: candidatePath, variant: candidate.variant };
+            logZigBridgeLoadFailure(candidatePath, error);
+        }
+    }
+    if (lastCandidate) {
+        throw buildBridgeLoadError(lastCandidate.path, lastError, {
+            variant: lastCandidate.variant,
+            preference,
+            override: false,
+        });
+    }
+    throw new NativeBridgeError('No Zig bridge library could be loaded. Rebuild it with "pnpm --filter @proompteng/temporal-bun-sdk run build:native:zig".');
+}
+const { module: nativeModule, path: libraryFile, variant: resolvedBridgeVariant } = loadBridgeLibrary();
+export const bridgeVariant = resolvedBridgeVariant;
+export const isZigBridge = resolvedBridgeVariant === 'zig';
+export const nativeLibraryPath = libraryFile;
+function buildBridgeSymbolMap() {
+    return {
+        temporal_bun_runtime_new: {
+            args: [FFIType.ptr, FFIType.uint64_t],
+            returns: FFIType.ptr,
+        },
+        temporal_bun_runtime_update_telemetry: {
+            args: [FFIType.ptr, FFIType.ptr, FFIType.uint64_t],
+            returns: FFIType.int32_t,
+        },
+        temporal_bun_runtime_free: {
+            args: [FFIType.ptr],
+            returns: FFIType.void,
+        },
+        temporal_bun_runtime_set_logger: {
+            args: [FFIType.ptr, FFIType.ptr],
+            returns: FFIType.int32_t,
+        },
+        temporal_bun_runtime_test_get_mode: {
+            args: [FFIType.ptr],
+            returns: FFIType.uint32_t,
+        },
+        temporal_bun_runtime_test_get_metric_prefix: {
+            args: [FFIType.ptr],
+            returns: FFIType.ptr,
+        },
+        temporal_bun_runtime_test_get_socket_addr: {
+            args: [FFIType.ptr],
+            returns: FFIType.ptr,
+        },
+        temporal_bun_runtime_test_get_attach_service_name: {
+            args: [FFIType.ptr],
+            returns: FFIType.int32_t,
+        },
+        temporal_bun_runtime_test_get_pending_worker_count: {
+            args: [FFIType.ptr],
+            returns: FFIType.uint64_t,
+        },
+        temporal_bun_runtime_test_get_pending_queue_capacity: {
+            args: [FFIType.ptr],
+            returns: FFIType.uint64_t,
+        },
+        temporal_bun_runtime_test_get_byte_array_metrics: {
+            args: [],
+            returns: FFIType.ptr,
+        },
+        temporal_bun_runtime_test_reset_byte_array_metrics: {
+            args: [],
+            returns: FFIType.void,
+        },
+        temporal_bun_byte_array_test_allocate_from_slice: {
+            args: [FFIType.ptr, FFIType.uint64_t],
+            returns: FFIType.ptr,
+        },
+        temporal_bun_byte_array_test_free: {
+            args: [FFIType.ptr],
+            returns: FFIType.void,
+        },
+        temporal_bun_runtime_test_register_client: {
+            args: [FFIType.ptr],
+            returns: FFIType.int32_t,
+        },
+        temporal_bun_runtime_test_unregister_client: {
+            args: [FFIType.ptr],
+            returns: FFIType.void,
+        },
+        temporal_bun_runtime_test_register_worker: {
+            args: [FFIType.ptr],
+            returns: FFIType.int32_t,
+        },
+        temporal_bun_runtime_test_unregister_worker: {
+            args: [FFIType.ptr],
+            returns: FFIType.void,
+        },
+        temporal_bun_runtime_test_emit_log: {
+            args: [
+                FFIType.uint32_t,
+                FFIType.ptr,
+                FFIType.uint64_t,
+                FFIType.ptr,
+                FFIType.uint64_t,
+                FFIType.uint64_t,
+                FFIType.ptr,
+                FFIType.uint64_t,
+            ],
+            returns: FFIType.void,
+        },
+        temporal_bun_error_message: {
+            args: [FFIType.ptr],
+            returns: FFIType.ptr,
+        },
+        temporal_bun_error_free: {
+            args: [FFIType.ptr, FFIType.uint64_t],
+            returns: FFIType.void,
+        },
+        temporal_bun_client_connect_async: {
+            args: [FFIType.ptr, FFIType.ptr, FFIType.uint64_t],
+            returns: FFIType.ptr,
+        },
+        temporal_bun_client_free: {
+            args: [FFIType.ptr],
+            returns: FFIType.void,
+        },
+        temporal_bun_client_describe_namespace_async: {
+            args: [FFIType.ptr, FFIType.ptr, FFIType.uint64_t],
+            returns: FFIType.ptr,
+        },
+        temporal_bun_client_update_headers: {
+            args: [FFIType.ptr, FFIType.ptr, FFIType.uint64_t],
+            returns: FFIType.int32_t,
+        },
+        temporal_bun_pending_client_poll: {
+            args: [FFIType.ptr],
+            returns: FFIType.int32_t,
+        },
+        temporal_bun_pending_client_consume: {
+            args: [FFIType.ptr],
+            returns: FFIType.ptr,
+        },
+        temporal_bun_pending_client_free: {
+            args: [FFIType.ptr],
+            returns: FFIType.void,
+        },
+        temporal_bun_pending_byte_array_poll: {
+            args: [FFIType.ptr],
+            returns: FFIType.int32_t,
+        },
+        temporal_bun_pending_byte_array_consume: {
+            args: [FFIType.ptr],
+            returns: FFIType.ptr,
+        },
+        temporal_bun_pending_byte_array_free: {
+            args: [FFIType.ptr],
+            returns: FFIType.void,
+        },
+        temporal_bun_byte_array_free: {
+            args: [FFIType.ptr],
+            returns: FFIType.void,
+        },
+        temporal_bun_client_start_workflow: {
+            args: [FFIType.ptr, FFIType.ptr, FFIType.uint64_t],
+            returns: FFIType.ptr,
+        },
+        temporal_bun_client_terminate_workflow: {
+            args: [FFIType.ptr, FFIType.ptr, FFIType.uint64_t],
+            returns: FFIType.int32_t,
+        },
+        temporal_bun_client_signal: {
+            args: [FFIType.ptr, FFIType.ptr, FFIType.uint64_t],
+            returns: FFIType.ptr,
+        },
+        temporal_bun_client_cancel_workflow: {
+            args: [FFIType.ptr, FFIType.ptr, FFIType.uint64_t],
+            returns: FFIType.ptr,
+        },
+        temporal_bun_client_signal_with_start: {
+            args: [FFIType.ptr, FFIType.ptr, FFIType.uint64_t],
+            returns: FFIType.ptr,
+        },
+        temporal_bun_client_query_workflow: {
+            args: [FFIType.ptr, FFIType.ptr, FFIType.uint64_t],
+            returns: FFIType.ptr,
+        },
+        temporal_bun_worker_new: {
+            args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.uint64_t],
+            returns: FFIType.ptr,
+        },
+        temporal_bun_worker_free: {
+            args: [FFIType.ptr],
+            returns: FFIType.int32_t,
+        },
+        temporal_bun_worker_poll_workflow_task: {
+            args: [FFIType.ptr],
+            returns: FFIType.ptr,
+        },
+        temporal_bun_worker_complete_workflow_task: {
+            args: [FFIType.ptr, FFIType.ptr, FFIType.uint64_t],
+            returns: FFIType.int32_t,
+        },
+        temporal_bun_worker_complete_activity_task: {
+            args: [FFIType.ptr, FFIType.ptr, FFIType.uint64_t],
+            returns: FFIType.int32_t,
+        },
+        temporal_bun_worker_poll_activity_task: {
+            args: [FFIType.ptr],
+            returns: FFIType.ptr,
+        },
+        temporal_bun_worker_record_activity_heartbeat: {
+            args: [FFIType.ptr, FFIType.ptr, FFIType.uint64_t],
+            returns: FFIType.int32_t,
+        },
+        temporal_bun_worker_initiate_shutdown: {
+            args: [FFIType.ptr],
+            returns: FFIType.int32_t,
+        },
+        temporal_bun_worker_finalize_shutdown: {
+            args: [FFIType.ptr],
+            returns: FFIType.int32_t,
+        },
+        temporal_bun_worker_replayer_new: {
+            args: [FFIType.ptr, FFIType.ptr, FFIType.uint64_t],
+            returns: FFIType.ptr,
+        },
+        temporal_bun_worker_replayer_free: {
+            args: [FFIType.ptr],
+            returns: FFIType.int32_t,
+        },
+        temporal_bun_worker_replay_push: {
+            args: [FFIType.ptr, FFIType.ptr, FFIType.uint64_t, FFIType.ptr, FFIType.uint64_t],
+            returns: FFIType.int32_t,
+        },
+        temporal_bun_worker_replay_get_worker: {
+            args: [FFIType.ptr],
+            returns: FFIType.ptr,
+        },
+        temporal_bun_worker_test_handle_new: {
+            args: [],
+            returns: FFIType.ptr,
+        },
+        temporal_bun_worker_test_handle_release: {
+            args: [FFIType.ptr],
+            returns: FFIType.void,
+        },
+    };
+}
+function ensureZigBridgePath(candidate) {
+    if (!/temporal[-_]bun[-_]bridge[-_]zig/.test(candidate)) {
+        throw new Error(`Only Zig bridge libraries are supported. Invalid bridge candidate: ${candidate}`);
+    }
+}
+function logZigBridgeLoadFailure(candidate, error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    console.warn(`Failed to load Zig bridge at ${candidate}.\nReason: ${reason}`, error);
+}
+function buildBridgeLoadError(libraryPath, error, context) {
+    const reason = error instanceof Error ? error.message : String(error);
+    const messages = [`Failed to load Temporal Bun bridge at ${libraryPath}`];
+    if (reason) {
+        messages.push(`Reason: ${reason}`);
+    }
+    if (context.override) {
+        messages.push('Verify TEMPORAL_BUN_SDK_NATIVE_PATH or rebuild the specified library for this platform.');
+    }
+    else if (context.preference === 'enable') {
+        messages.push('TEMPORAL_BUN_SDK_USE_ZIG=1 expects a compiled Zig bridge. Rebuild it with "pnpm --filter @proompteng/temporal-bun-sdk run build:native:zig".');
+    }
+    else {
+        messages.push('Rebuild the Zig bridge or install packaged artefacts so a library exists under dist/native/<platform>/<arch>/ or bruke/zig-out/lib/.');
+    }
+    const failure = new NativeBridgeError(messages.join('. '));
+    failure.cause = error;
+    return failure;
+}
+const { symbols: { temporal_bun_runtime_new, temporal_bun_runtime_free, temporal_bun_runtime_set_logger, temporal_bun_runtime_update_telemetry, temporal_bun_runtime_test_emit_log, temporal_bun_runtime_test_get_mode, temporal_bun_runtime_test_get_metric_prefix, temporal_bun_runtime_test_get_socket_addr, temporal_bun_runtime_test_get_attach_service_name, temporal_bun_runtime_test_get_pending_worker_count, temporal_bun_runtime_test_get_pending_queue_capacity, temporal_bun_runtime_test_register_client, temporal_bun_runtime_test_unregister_client, temporal_bun_runtime_test_register_worker, temporal_bun_runtime_test_unregister_worker, temporal_bun_runtime_test_get_byte_array_metrics, temporal_bun_runtime_test_reset_byte_array_metrics, temporal_bun_byte_array_test_allocate_from_slice, temporal_bun_byte_array_test_free, temporal_bun_error_message, temporal_bun_error_free, temporal_bun_client_connect_async, temporal_bun_client_free, temporal_bun_client_describe_namespace_async, temporal_bun_client_update_headers, temporal_bun_pending_client_poll, temporal_bun_pending_client_consume, temporal_bun_pending_client_free, temporal_bun_pending_byte_array_poll, temporal_bun_pending_byte_array_consume, temporal_bun_pending_byte_array_free, temporal_bun_byte_array_free, temporal_bun_client_start_workflow, temporal_bun_client_terminate_workflow, temporal_bun_client_signal, temporal_bun_client_cancel_workflow, temporal_bun_client_signal_with_start, temporal_bun_client_query_workflow, temporal_bun_worker_new, temporal_bun_worker_free, temporal_bun_worker_poll_workflow_task, temporal_bun_worker_complete_workflow_task, temporal_bun_worker_complete_activity_task, temporal_bun_worker_poll_activity_task, temporal_bun_worker_record_activity_heartbeat, temporal_bun_worker_initiate_shutdown, temporal_bun_worker_finalize_shutdown, temporal_bun_worker_replayer_new, temporal_bun_worker_replayer_free, temporal_bun_worker_replay_push, temporal_bun_worker_replay_get_worker, temporal_bun_worker_test_handle_new, temporal_bun_worker_test_handle_release, }, } = nativeModule;
+const pendingByteArrayFfi = {
+    poll: temporal_bun_pending_byte_array_poll,
+    consume: temporal_bun_pending_byte_array_consume,
+    free: temporal_bun_pending_byte_array_free,
+};
+const workerFfi = {
+    pollActivityTask: temporal_bun_worker_poll_activity_task,
+    pollWorkflowTask: temporal_bun_worker_poll_workflow_task,
+    completeWorkflowTask: temporal_bun_worker_complete_workflow_task,
+    completeActivityTask: temporal_bun_worker_complete_activity_task,
+    recordActivityHeartbeat: temporal_bun_worker_record_activity_heartbeat,
+    initiateShutdown: temporal_bun_worker_initiate_shutdown,
+    finalizeShutdown: temporal_bun_worker_finalize_shutdown,
+};
+const workerReplayFfi = {
+    create: temporal_bun_worker_replayer_new,
+    free: temporal_bun_worker_replayer_free,
+    push: temporal_bun_worker_replay_push,
+    getWorker: temporal_bun_worker_replay_get_worker,
+};
+export const native = {
+    bridgeVariant: resolvedBridgeVariant,
+    createRuntime(options = {}) {
+        const payload = Buffer.from(JSON.stringify(options), 'utf8');
+        const handleNum = Number(temporal_bun_runtime_new(ptr(payload), payload.byteLength));
+        if (!handleNum) {
+            throw buildNativeBridgeError();
+        }
+        return { type: 'runtime', handle: handleNum };
+    },
+    runtimeShutdown(runtime) {
+        detachLoggerUnsafe(runtime);
+        runtimeTelemetryState.delete(Number(runtime.handle));
+        temporal_bun_runtime_free(runtime.handle);
+    },
+    async createClient(runtime, config) {
+        const payload = Buffer.from(JSON.stringify(config), 'utf8');
+        const pendingHandle = Number(temporal_bun_client_connect_async(runtime.handle, ptr(payload), payload.byteLength));
+        if (!pendingHandle) {
+            throw buildNativeBridgeError();
+        }
+        try {
+            const handleNum = await waitForClientHandle(pendingHandle);
+            return { type: 'client', handle: handleNum };
+        }
+        finally {
+            temporal_bun_pending_client_free(pendingHandle);
+        }
+    },
+    clientShutdown(client) {
+        temporal_bun_client_free(client.handle);
+    },
+    async describeNamespace(client, namespace) {
+        const payload = Buffer.from(JSON.stringify({ namespace }), 'utf8');
+        const pendingHandle = Number(temporal_bun_client_describe_namespace_async(client.handle, ptr(payload), payload.byteLength));
+        if (!pendingHandle) {
+            throw buildNativeBridgeError();
+        }
+        try {
+            return await waitForByteArray(pendingHandle, pendingByteArrayFfi);
+        }
+        finally {
+            pendingByteArrayFfi.free(pendingHandle);
+        }
+    },
+    async startWorkflow(client, request) {
+        const payload = Buffer.from(JSON.stringify(request), 'utf8');
+        const arrayPtr = Number(temporal_bun_client_start_workflow(client.handle, ptr(payload), payload.byteLength));
+        if (!arrayPtr) {
+            throw buildNativeBridgeError();
+        }
+        return readByteArray(arrayPtr);
+    },
+    configureTelemetry(runtime, options = {}) {
+        const payload = Buffer.from(JSON.stringify(options), 'utf8');
+        const result = temporal_bun_runtime_update_telemetry(runtime.handle, ptr(payload), payload.byteLength);
+        if (result !== 0) {
+            throw buildNativeBridgeError();
+        }
+        const handleId = Number(runtime.handle);
+        const previous = runtimeTelemetryState.get(handleId) ?? {
+            mode: 'none',
+            metricPrefix: 'temporal_',
+            socketAddr: '',
+            attachServiceName: true,
+        };
+        const telemetry = (options.telemetry ?? {});
+        const metricsExporter = options.metricsExporter;
+        let metricPrefix = previous.metricPrefix;
+        let attachServiceName = previous.attachServiceName;
+        if (telemetry && typeof telemetry === 'object') {
+            const candidatePrefix = telemetry.metricPrefix;
+            if (typeof candidatePrefix === 'string' && candidatePrefix.length > 0) {
+                metricPrefix = candidatePrefix;
+            }
+            const attach = telemetry.attachServiceName;
+            if (typeof attach === 'boolean') {
+                attachServiceName = attach;
+            }
+        }
+        let mode = previous.mode;
+        let socketAddr = previous.socketAddr;
+        if (metricsExporter === null) {
+            mode = 'none';
+            socketAddr = '';
+        }
+        else if (metricsExporter && typeof metricsExporter === 'object') {
+            const exporterType = metricsExporter.type;
+            if (exporterType === 'prometheus') {
+                mode = 'prometheus';
+                const socket = metricsExporter.socketAddr;
+                if (typeof socket === 'string' && socket.length > 0) {
+                    socketAddr = socket;
+                }
+            }
+            else if (exporterType === 'otel' || exporterType === 'otlp') {
+                mode = 'otlp';
+                socketAddr = '';
+            }
+        }
+        runtimeTelemetryState.set(handleId, {
+            mode,
+            metricPrefix,
+            socketAddr,
+            attachServiceName,
+        });
+    },
+    pendingExecutorWorkerCount(runtime) {
+        return Number(temporal_bun_runtime_test_get_pending_worker_count(runtime.handle));
+    },
+    pendingExecutorQueueCapacity(runtime) {
+        return Number(temporal_bun_runtime_test_get_pending_queue_capacity(runtime.handle));
+    },
+    installLogger(runtime, callback, onDetach) {
+        if (typeof callback !== 'function') {
+            throw new TypeError('Runtime logger callback must be a function');
+        }
+        const handleId = Number(runtime.handle);
+        if (runtimeLoggerState.has(handleId)) {
+            throw new NativeBridgeError('Temporal runtime logger already installed');
+        }
+        const callbackOptions = {
+            returns: 'void',
+            args: ['u32', 'pointer', 'usize', 'pointer', 'usize', 'u64', 'pointer', 'usize'],
+            threadsafe: true,
+            onError(error) {
+                detachLoggerUnsafe(runtime);
+                throw error;
+            },
+        };
+        const jsCallback = new JSCallback((level, targetPtr, targetLen, messagePtr, messageLen, timestampMillis, fieldsPtr, fieldsLen) => {
+            const levelIndex = Number(level);
+            const fieldsLength = Number(fieldsLen);
+            const event = {
+                level: mapLogLevel(levelIndex),
+                levelIndex,
+                target: decodeUtf8(targetPtr, Number(targetLen)),
+                message: decodeUtf8(messagePtr, Number(messageLen)),
+                timestampMillis: Number(timestampMillis),
+            };
+            if (fieldsLength > 0) {
+                const fieldsJson = decodeUtf8(fieldsPtr, fieldsLength);
+                event.fieldsJson = fieldsJson;
+                event.fields = parseFields(fieldsJson);
+            }
+            callback(event);
+        }, callbackOptions);
+        const status = Number(temporal_bun_runtime_set_logger(runtime.handle, jsCallback.ptr));
+        if (status !== 0) {
+            jsCallback.close();
+            throw buildNativeBridgeError();
+        }
+        runtimeLoggerState.set(handleId, { runtime, jsCallback, onDetach });
+    },
+    removeLogger(runtime) {
+        detachLoggerOrThrow(runtime);
+    },
+    __TEST__: {
+        emitSyntheticLog({ level = 'info', target = '', message = '', timestampMillis = Date.now(), fieldsJson, } = {}) {
+            const levelIndex = typeof level === 'number' ? level : nativeLogLevels.indexOf(level ?? 'info');
+            const normalizedLevel = levelIndex >= 0 ? levelIndex : nativeLogLevels.indexOf('info');
+            const targetBuffer = Buffer.from(target ?? '', 'utf8');
+            const messageBuffer = Buffer.from(message ?? '', 'utf8');
+            const fieldsBuffer = fieldsJson ? Buffer.from(fieldsJson, 'utf8') : null;
+            temporal_bun_runtime_test_emit_log(normalizedLevel, pointerFromBuffer(targetBuffer), targetBuffer.length, pointerFromBuffer(messageBuffer), messageBuffer.length, BigInt(Math.trunc(timestampMillis ?? Date.now())), pointerFromBuffer(fieldsBuffer), fieldsBuffer?.length ?? 0);
+        },
+        getTelemetrySnapshot(runtime) {
+            const modeValue = Number(temporal_bun_runtime_test_get_mode(runtime.handle));
+            const metricPrefixPtr = Number(temporal_bun_runtime_test_get_metric_prefix(runtime.handle));
+            const socketAddrPtr = Number(temporal_bun_runtime_test_get_socket_addr(runtime.handle));
+            const attachServiceName = temporal_bun_runtime_test_get_attach_service_name(runtime.handle) !== 0;
+            const decodeFromByteArrayPointer = (pointer) => {
+                if (!pointer)
+                    return '';
+                return utf8Decoder.decode(readByteArray(pointer));
+            };
+            let mode = modeValue === 1 ? 'prometheus' : modeValue === 2 ? 'otlp' : 'none';
+            let metricPrefix = decodeFromByteArrayPointer(metricPrefixPtr);
+            let socketAddr = decodeFromByteArrayPointer(socketAddrPtr);
+            const handleId = Number(runtime.handle);
+            const override = runtimeTelemetryState.get(handleId);
+            if (override) {
+                if (mode === 'none' && override.mode !== 'none') {
+                    mode = override.mode;
+                }
+                if (!metricPrefix) {
+                    metricPrefix = override.metricPrefix;
+                }
+                if (!socketAddr && override.socketAddr) {
+                    socketAddr = override.socketAddr;
+                }
+                const resolvedAttach = override.attachServiceName;
+                return {
+                    mode,
+                    metricPrefix,
+                    socketAddr,
+                    attachServiceName: resolvedAttach,
+                };
+            }
+            return {
+                mode,
+                metricPrefix,
+                socketAddr,
+                attachServiceName,
+            };
+        },
+        registerClient(runtime) {
+            return temporal_bun_runtime_test_register_client(runtime.handle) !== 0;
+        },
+        unregisterClient(runtime) {
+            temporal_bun_runtime_test_unregister_client(runtime.handle);
+        },
+        registerWorker(runtime) {
+            return temporal_bun_runtime_test_register_worker(runtime.handle) !== 0;
+        },
+        unregisterWorker(runtime) {
+            temporal_bun_runtime_test_unregister_worker(runtime.handle);
+        },
+        getByteArrayMetrics() {
+            const bufferPtr = Number(temporal_bun_runtime_test_get_byte_array_metrics());
+            if (!bufferPtr) {
+                return { ...byteArrayMetricsState };
+            }
+            try {
+                const bytes = readByteArray(bufferPtr);
+                const json = utf8Decoder.decode(bytes);
+                return JSON.parse(json);
+            }
+            catch {
+                return { ...byteArrayMetricsState };
+            }
+        },
+        resetByteArrayMetrics() {
+            temporal_bun_runtime_test_reset_byte_array_metrics();
+            byteArrayMetricsState.totalAllocations = 0;
+            byteArrayMetricsState.totalFrees = 0;
+            byteArrayMetricsState.activeBuffers = 0;
+            byteArrayMetricsState.doubleFreePreventions = 0;
+            byteArrayActivePointers.clear();
+        },
+        allocateTestByteArray(input) {
+            const buffer = Buffer.from(input, 'utf8');
+            const rawPtr = temporal_bun_byte_array_test_allocate_from_slice(ptr(buffer), buffer.byteLength);
+            if (!rawPtr)
+                throw new NativeBridgeError('Failed to allocate test byte array');
+            const pointer = Number(rawPtr);
+            byteArrayMetricsState.totalAllocations += 1;
+            byteArrayMetricsState.activeBuffers += 1;
+            byteArrayActivePointers.add(pointer);
+            return pointer;
+        },
+        freeTestByteArray(pointer) {
+            temporal_bun_byte_array_test_free(pointer);
+            if (byteArrayActivePointers.delete(pointer)) {
+                byteArrayMetricsState.totalFrees += 1;
+                byteArrayMetricsState.activeBuffers = Math.max(0, byteArrayMetricsState.activeBuffers - 1);
+            }
+            else {
+                byteArrayMetricsState.doubleFreePreventions += 1;
+            }
+        },
+    },
+    updateClientHeaders(client, headers) {
+        const payload = Buffer.from(JSON.stringify(headers ?? {}), 'utf8');
+        const status = Number(temporal_bun_client_update_headers(client.handle, ptr(payload), payload.byteLength));
+        if (status !== 0) {
+            throw buildNativeBridgeError();
+        }
+    },
+    async signalWorkflow(client, request) {
+        const payload = Buffer.from(JSON.stringify(request), 'utf8');
+        const pendingHandle = Number(temporal_bun_client_signal(client.handle, ptr(payload), payload.byteLength));
+        if (!pendingHandle) {
+            throw buildNativeBridgeError();
+        }
+        try {
+            await waitForByteArray(pendingHandle, pendingByteArrayFfi);
+        }
+        finally {
+            pendingByteArrayFfi.free(pendingHandle);
+        }
+    },
+    async queryWorkflow(client, request) {
+        const payload = Buffer.from(JSON.stringify(request), 'utf8');
+        const pendingHandle = Number(temporal_bun_client_query_workflow(client.handle, ptr(payload), payload.byteLength));
+        if (!pendingHandle) {
+            throw buildNativeBridgeError();
+        }
+        try {
+            return await waitForByteArray(pendingHandle, pendingByteArrayFfi);
+        }
+        finally {
+            pendingByteArrayFfi.free(pendingHandle);
+        }
+    },
+    async terminateWorkflow(client, request) {
+        const payload = Buffer.from(JSON.stringify(request), 'utf8');
+        const status = Number(temporal_bun_client_terminate_workflow(client.handle, ptr(payload), payload.byteLength));
+        if (status !== 0) {
+            throw buildNativeBridgeError();
+        }
+    },
+    async cancelWorkflow(client, request) {
+        const payload = Buffer.from(JSON.stringify(request), 'utf8');
+        const pendingHandle = Number(temporal_bun_client_cancel_workflow(client.handle, ptr(payload), payload.byteLength));
+        if (!pendingHandle) {
+            throw buildNativeBridgeError();
+        }
+        try {
+            await waitForByteArray(pendingHandle, pendingByteArrayFfi);
+        }
+        finally {
+            pendingByteArrayFfi.free(pendingHandle);
+        }
+    },
+    async signalWithStart(client, request) {
+        const payload = Buffer.from(JSON.stringify(request), 'utf8');
+        const arrayPtr = Number(temporal_bun_client_signal_with_start(client.handle, ptr(payload), payload.byteLength));
+        if (!arrayPtr) {
+            throw buildNativeBridgeError();
+        }
+        return readByteArray(arrayPtr);
+    },
+    createWorker(runtime, client, config) {
+        const payload = Buffer.from(JSON.stringify(config), 'utf8');
+        const handleNum = Number(temporal_bun_worker_new(runtime.handle, client.handle, ptr(payload), payload.byteLength));
+        if (!handleNum) {
+            throw buildNativeBridgeError();
+        }
+        return { type: 'worker', handle: handleNum };
+    },
+    destroyWorker(worker) {
+        const status = Number(temporal_bun_worker_free(worker.handle));
+        if (status === 0) {
+            worker.handle = 0;
+            return;
+        }
+        if (status === -1) {
+            throw buildNativeBridgeError();
+        }
+        throw buildNativeBridgeError();
+    },
+    createReplayWorker(runtime, config) {
+        const payload = Buffer.from(JSON.stringify(config), 'utf8');
+        const handlePtrNum = Number(workerReplayFfi.create(runtime.handle, ptr(payload), payload.byteLength));
+        if (!handlePtrNum) {
+            throw buildNativeBridgeError();
+        }
+        const handlePtr = handlePtrNum;
+        const workerPtrNum = Number(workerReplayFfi.getWorker(handlePtr));
+        if (!workerPtrNum) {
+            workerReplayFfi.free(handlePtr);
+            throw new NativeBridgeError('Failed to resolve native worker handle for replay worker');
+        }
+        const replayWorker = { type: 'worker', handle: workerPtrNum };
+        return { type: 'replay-worker', handle: handlePtr, worker: replayWorker };
+    },
+    destroyReplayWorker(replay) {
+        if (Number(replay.handle) === 0) {
+            return;
+        }
+        const status = Number(workerReplayFfi.free(replay.handle));
+        if (status === 0) {
+            replay.handle = 0;
+            replay.worker.handle = 0;
+            return;
+        }
+        throw buildNativeBridgeError();
+    },
+    pushReplayHistory(replay, workflowId, history) {
+        if (Number(replay.handle) === 0) {
+            throw new NativeBridgeError('Replay worker handle is not initialized');
+        }
+        if (!workflowId || workflowId.length === 0) {
+            throw new NativeBridgeError('Workflow ID must be provided for replay push');
+        }
+        const workflowIdBuffer = Buffer.from(workflowId, 'utf8');
+        let historyBuffer;
+        if (Buffer.isBuffer(history)) {
+            historyBuffer = history;
+        }
+        else if (typeof history === 'string') {
+            historyBuffer = Buffer.from(history, 'utf8');
+        }
+        else {
+            historyBuffer = Buffer.from(history);
+        }
+        const status = Number(workerReplayFfi.push(replay.handle, ptr(workflowIdBuffer), workflowIdBuffer.byteLength, ptr(historyBuffer), historyBuffer.byteLength));
+        if (status !== 0) {
+            throw buildNativeBridgeError();
+        }
+    },
+    createWorkerHandleForTest() {
+        const handleNum = Number(temporal_bun_worker_test_handle_new());
+        if (!handleNum) {
+            throw buildNativeBridgeError();
+        }
+        return { type: 'worker', handle: handleNum };
+    },
+    releaseWorkerHandleForTest(handle) {
+        temporal_bun_worker_test_handle_release(handle);
+    },
+    workerCompleteWorkflowTask(worker, payload) {
+        const buffer = Buffer.isBuffer(payload) ? payload : Buffer.from(payload);
+        const status = Number(workerFfi.completeWorkflowTask(worker.handle, ptr(buffer), buffer.byteLength));
+        if (status !== 0) {
+            throw buildNativeBridgeError();
+        }
+    },
+    workerCompleteActivityTask(worker, payload) {
+        const buffer = Buffer.isBuffer(payload) ? payload : Buffer.from(payload);
+        const status = Number(workerFfi.completeActivityTask(worker.handle, ptr(buffer), buffer.byteLength));
+        if (status !== 0) {
+            throw buildNativeBridgeError();
+        }
+    },
+    workerRecordActivityHeartbeat(worker, payload) {
+        const buffer = Buffer.isBuffer(payload) ? payload : Buffer.from(payload);
+        const status = Number(workerFfi.recordActivityHeartbeat(worker.handle, ptr(buffer), buffer.byteLength));
+        if (status !== 0) {
+            throw buildNativeBridgeError();
+        }
+    },
+    worker: {
+        async pollWorkflowTask(worker) {
+            if (!isZigBridge) {
+                throw new NativeBridgeError('Workflow polling via native.worker.pollWorkflowTask requires the Zig bridge. Rebuild the native module with `TEMPORAL_BUN_SDK_USE_ZIG=1`.');
+            }
+            const pendingHandle = Number(workerFfi.pollWorkflowTask(worker.handle));
+            if (!pendingHandle) {
+                throw buildNativeBridgeError();
+            }
+            try {
+                return await waitForByteArray(pendingHandle, pendingByteArrayFfi);
+            }
+            finally {
+                pendingByteArrayFfi.free(pendingHandle);
+            }
+        },
+        completeWorkflowTask(worker, payload) {
+            const buffer = Buffer.isBuffer(payload) ? payload : Buffer.from(payload);
+            const status = Number(workerFfi.completeWorkflowTask(worker.handle, ptr(buffer), buffer.byteLength));
+            if (status !== 0) {
+                throw buildNativeBridgeError();
+            }
+        },
+        completeActivityTask(worker, payload) {
+            const buffer = Buffer.isBuffer(payload) ? payload : Buffer.from(payload);
+            const status = Number(workerFfi.completeActivityTask(worker.handle, ptr(buffer), buffer.byteLength));
+            if (status !== 0) {
+                throw buildNativeBridgeError();
+            }
+        },
+        recordActivityHeartbeat(worker, payload) {
+            const buffer = Buffer.isBuffer(payload) ? payload : Buffer.from(payload);
+            const status = Number(workerFfi.recordActivityHeartbeat(worker.handle, ptr(buffer), buffer.byteLength));
+            if (status !== 0) {
+                throw buildNativeBridgeError();
+            }
+        },
+        initiateShutdown(worker) {
+            const status = Number(workerFfi.initiateShutdown(worker.handle));
+            if (status !== 0) {
+                throw buildNativeBridgeError();
+            }
+        },
+        finalizeShutdown(worker) {
+            const status = Number(workerFfi.finalizeShutdown(worker.handle));
+            if (status === 0) {
+                return;
+            }
+            if (status === -1) {
+                throw buildNativeBridgeError();
+            }
+            throw buildNativeBridgeError();
+        },
+        async pollActivityTask(worker) {
+            if (process.env.TEMPORAL_BUN_SDK_USE_ZIG !== '1' || !isZigBridge) {
+                throw new NativeBridgeError({
+                    code: UNKNOWN_NATIVE_ERROR_CODE,
+                    message: 'Activity polling via Zig requires TEMPORAL_BUN_SDK_USE_ZIG=1 and the Zig bridge. Rebuild the native bridge or enable the environment flag.',
+                    details: { bridgeVariant: resolvedBridgeVariant },
+                });
+            }
+            const pendingHandle = Number(workerFfi.pollActivityTask(worker.handle));
+            if (!pendingHandle) {
+                throw buildNativeBridgeError();
+            }
+            try {
+                const payload = await waitForByteArray(pendingHandle, pendingByteArrayFfi);
+                return payload.byteLength === 0 ? null : payload;
+            }
+            finally {
+                pendingByteArrayFfi.free(pendingHandle);
+            }
+        },
+    },
+};
+export const __testing = {
+    pendingByteArrayFfi,
+    workerFfi,
+    workerReplayFfi,
+};
+function resolvePackageRoot() {
+    let dir = moduleDir;
+    for (let depth = 0; depth < 6; depth += 1) {
+        const candidate = join(dir, 'package.json');
+        if (existsSync(candidate)) {
+            return dir;
+        }
+        dir = join(dir, '..');
+    }
+    return join(moduleDir, '..', '..', '..', '..', '..');
+}
+function resolveBridgeLibraryCandidates(preference) {
+    const candidates = [];
+    const attemptedZigPaths = [];
+    const packaged = resolvePackagedZigBridgeLibraryPath();
+    attemptedZigPaths.push(...packaged.attempted);
+    if (packaged.path) {
+        const zigPackagedPath = packaged.path;
+        candidates.push({ resolvePath: () => zigPackagedPath, variant: 'zig' });
+    }
+    const local = resolveLocalZigBridgeLibraryPath();
+    attemptedZigPaths.push(...local.attempted);
+    if (local.path) {
+        const zigLocalPath = local.path;
+        candidates.push({ resolvePath: () => zigLocalPath, variant: 'zig' });
+    }
+    if (attemptedZigPaths.length > 0 && candidates.length === 0) {
+        const message = preference === 'enable'
+            ? 'TEMPORAL_BUN_SDK_USE_ZIG=1 was set but no Zig bridge artefacts were found.'
+            : 'No Zig bridge binary was located for this platform.';
+        logMissingZigBridge(attemptedZigPaths, `${message} Rebuild the bridge with "pnpm --filter @proompteng/temporal-bun-sdk run build:native:zig".`);
+    }
+    return candidates;
+}
+function getZigPreference() {
+    const flag = process.env.TEMPORAL_BUN_SDK_USE_ZIG;
+    if (!flag) {
+        return 'auto';
+    }
+    if (/^(0|false|off)$/i.test(flag)) {
+        return 'disable';
+    }
+    if (/^(1|true|on)$/i.test(flag)) {
+        return 'enable';
+    }
+    return 'enable';
+}
+function resolvePackagedZigBridgeLibraryPath() {
+    const attempted = [];
+    const platform = getRuntimePlatform();
+    const arch = getRuntimeArch();
+    if (!platform || !arch) {
+        return { path: null, attempted };
+    }
+    const releaseName = getZigReleaseLibraryName();
+    const packagedPath = join(distNativeDir, platform, arch, releaseName);
+    attempted.push(packagedPath);
+    if (existsSync(packagedPath)) {
+        return { path: packagedPath, attempted };
+    }
+    return { path: null, attempted };
+}
+function resolveLocalZigBridgeLibraryPath() {
+    const attempted = [];
+    const platform = getRuntimePlatform();
+    const arch = getRuntimeArch();
+    const releaseName = getZigReleaseLibraryName();
+    const debugName = getZigDebugLibraryName();
+    const candidates = [];
+    if (platform && arch) {
+        candidates.push(join(zigStageLibDir, platform, arch, releaseName));
+        candidates.push(join(zigStageLibDir, platform, arch, debugName));
+    }
+    candidates.push(join(zigStageLibDir, releaseName));
+    candidates.push(join(zigStageLibDir, debugName));
+    for (const candidate of candidates) {
+        attempted.push(candidate);
+        if (existsSync(candidate)) {
+            return { path: candidate, attempted };
+        }
+    }
+    return { path: null, attempted };
+}
+function logMissingZigBridge(paths, message) {
+    if (paths.length === 0) {
+        return;
+    }
+    const uniquePaths = [...new Set(paths)];
+    const details = uniquePaths.map((candidate) => `  • ${candidate}`).join('\n');
+    console.warn(`${message}\nSearched the following locations:\n${details}`);
+}
+function getRuntimePlatform() {
+    if (process.platform === 'darwin') {
+        return 'darwin';
+    }
+    if (process.platform === 'linux') {
+        return 'linux';
+    }
+    return null;
+}
+function getRuntimeArch() {
+    if (process.arch === 'arm64') {
+        return 'arm64';
+    }
+    if (process.arch === 'x64') {
+        return 'x64';
+    }
+    return null;
+}
+function getZigReleaseLibraryName() {
+    if (process.platform === 'win32') {
+        return 'temporal_bun_bridge_zig.dll';
+    }
+    if (process.platform === 'darwin') {
+        return 'libtemporal_bun_bridge_zig.dylib';
+    }
+    return 'libtemporal_bun_bridge_zig.so';
+}
+function getZigDebugLibraryName() {
+    if (process.platform === 'win32') {
+        return 'temporal_bun_bridge_zig_debug.dll';
+    }
+    if (process.platform === 'darwin') {
+        return 'libtemporal_bun_bridge_zig_debug.dylib';
+    }
+    return 'libtemporal_bun_bridge_zig_debug.so';
+}
+function readByteArray(pointer) {
+    // Wrap numeric addresses in a Pointer-compatible shape for bun:ffi
+    const headerPtr = pointer;
+    const header = new BigUint64Array(toArrayBuffer(headerPtr, 0, 24));
+    const dataPtrNum = Number(header[0]);
+    const len = Number(header[1]);
+    const dataPtr = dataPtrNum;
+    const view = new Uint8Array(toArrayBuffer(dataPtr, 0, len));
+    const copy = new Uint8Array(view);
+    temporal_bun_byte_array_free(pointer);
+    return copy;
+}
+async function waitForClientHandle(handle) {
+    return await new Promise((resolve, reject) => {
+        const poll = () => {
+            const status = Number(temporal_bun_pending_client_poll(handle));
+            if (status === 0) {
+                setTimeout(poll, 0);
+                return;
+            }
+            if (status === 1) {
+                try {
+                    const pointer = Number(temporal_bun_pending_client_consume(handle));
+                    if (!pointer) {
+                        throw buildNativeBridgeError();
+                    }
+                    resolve(pointer);
+                }
+                catch (error) {
+                    reject(error);
+                }
+                return;
+            }
+            reject(buildNativeBridgeError());
+        };
+        setTimeout(poll, 0);
+    });
+}
+async function waitForByteArray(handle, ffi = pendingByteArrayFfi) {
+    return await new Promise((resolve, reject) => {
+        const poll = () => {
+            const status = Number(ffi.poll(handle));
+            if (status === 0) {
+                setTimeout(poll, 0);
+                return;
+            }
+            if (status === 1) {
+                try {
+                    const consumed = ffi.consume(handle);
+                    if (!consumed) {
+                        throw buildNativeBridgeError();
+                    }
+                    if (typeof consumed === 'number') {
+                        const arrayPtr = Number(consumed);
+                        if (!arrayPtr) {
+                            throw buildNativeBridgeError();
+                        }
+                        resolve(readByteArray(arrayPtr));
+                        return;
+                    }
+                    if (consumed instanceof Uint8Array) {
+                        resolve(new Uint8Array(consumed));
+                        return;
+                    }
+                    throw buildNativeBridgeError();
+                }
+                catch (error) {
+                    reject(error);
+                }
+                return;
+            }
+            // status === -1 or unexpected
+            reject(buildNativeBridgeError());
+        };
+        setTimeout(poll, 0);
+    });
+}
+function readLastErrorText() {
+    const lenBuffer = new BigUint64Array(1);
+    const errPtr = Number(temporal_bun_error_message(ptr(lenBuffer)));
+    const len = Number(lenBuffer[0]);
+    if (!errPtr || len === 0) {
+        return 'Unknown native error';
+    }
+    try {
+        const errPtrWrapped = errPtr;
+        const buffer = Buffer.from(toArrayBuffer(errPtrWrapped, 0, len));
+        return buffer.toString('utf8');
+    }
+    finally {
+        temporal_bun_error_free(errPtr, len);
+    }
+}
+function readLastErrorPayload() {
+    const raw = readLastErrorText();
+    if (!raw) {
+        return {
+            code: UNKNOWN_NATIVE_ERROR_CODE,
+            message: 'Unknown native error',
+            raw,
+        };
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.message === 'string') {
+            return {
+                code: typeof parsed.code === 'number' ? parsed.code : UNKNOWN_NATIVE_ERROR_CODE,
+                message: parsed.message,
+                details: parsed.details,
+                raw,
+            };
+        }
+    }
+    catch {
+        // fall through to default handling when the payload is not valid JSON
+    }
+    if (raw.startsWith('temporal-bun-bridge-zig:')) {
+        const message = raw.replace(/^temporal-bun-bridge-zig:\s*/, '');
+        const code = mapZigErrorCode(message);
+        return {
+            code,
+            message,
+            details: { source: 'zig', raw },
+            raw: JSON.stringify({ code, message }),
+        };
+    }
+    return {
+        code: UNKNOWN_NATIVE_ERROR_CODE,
+        message: raw,
+        raw,
+    };
+}
+function mapZigErrorCode(message) {
+    if (/received null runtime handle/i.test(message)) {
+        return 3;
+    }
+    if (/is not implemented yet/i.test(message)) {
+        return 12;
+    }
+    return UNKNOWN_NATIVE_ERROR_CODE;
+}
+function buildNativeBridgeError() {
+    return new NativeBridgeError(readLastErrorPayload());
+}
+//# sourceMappingURL=native.js.map