@proompteng/temporal-bun-sdk 0.1.0

package/dist/src/worker/runtime.js

@@ -0,0 +1,1415 @@
+import { pathToFileURL } from 'node:url';
+import { create } from '@bufbuild/protobuf';
+import { Code, ConnectError, createClient } from '@connectrpc/connect';
+import { createGrpcTransport } from '@connectrpc/connect-node';
+import { Cause, Effect, Exit, Fiber } from 'effect';
+import { makeActivityLifecycle, } from '../activities/lifecycle';
+import { buildTransportOptions, normalizeTemporalAddress } from '../client';
+import { durationFromMillis, durationToMillis } from '../common/duration';
+import { createDefaultDataConverter, decodePayloadsToValues, encodeValuesToPayloads, } from '../common/payloads/converter';
+import { encodeErrorToFailure, encodeFailurePayloads, failureToError } from '../common/payloads/failure';
+import { sleep } from '../common/sleep';
+import { loadTemporalConfig } from '../config';
+import { createObservabilityServices } from '../observability';
+import { CommandSchema, RecordMarkerCommandAttributesSchema, } from '../proto/temporal/api/command/v1/message_pb';
+import { PayloadsSchema, WorkflowExecutionSchema, } from '../proto/temporal/api/common/v1/message_pb';
+import { WorkerDeploymentOptionsSchema, } from '../proto/temporal/api/deployment/v1/message_pb';
+import { CommandType } from '../proto/temporal/api/enums/v1/command_type_pb';
+import { WorkerVersioningMode } from '../proto/temporal/api/enums/v1/deployment_pb';
+import { EventType } from '../proto/temporal/api/enums/v1/event_type_pb';
+import { WorkflowTaskFailedCause } from '../proto/temporal/api/enums/v1/failed_cause_pb';
+import { HistoryEventFilterType, TimeoutType, VersioningBehavior } from '../proto/temporal/api/enums/v1/workflow_pb';
+import { StickyExecutionAttributesSchema, TaskQueueSchema, } from '../proto/temporal/api/taskqueue/v1/message_pb';
+import { GetWorkflowExecutionHistoryRequestSchema, PollActivityTaskQueueRequestSchema, PollWorkflowTaskQueueRequestSchema, RespondActivityTaskCanceledRequestSchema, RespondActivityTaskCompletedRequestSchema, RespondActivityTaskFailedRequestSchema, RespondWorkflowTaskCompletedRequestSchema, RespondWorkflowTaskFailedRequestSchema, } from '../proto/temporal/api/workflowservice/v1/request_response_pb';
+import { WorkflowService } from '../proto/temporal/api/workflowservice/v1/service_pb';
+import { WorkflowNondeterminismError } from '../workflow/errors';
+import { WorkflowExecutor } from '../workflow/executor';
+import { WorkflowRegistry } from '../workflow/registry';
+import { DETERMINISM_MARKER_NAME, diffDeterminismState, encodeDeterminismMarkerDetails, ingestWorkflowHistory, resolveHistoryLastEventId, } from '../workflow/replay';
+import { runWithActivityContext } from './activity-context';
+import { checkWorkerVersioningCapability, registerWorkerBuildIdCompatibility } from './build-id';
+import { makeWorkerScheduler, } from './concurrency';
+import { makeStickyCache, } from './sticky-cache';
+const POLL_TIMEOUT_MS = 60_000;
+const RESPOND_TIMEOUT_MS = 15_000;
+const HISTORY_FETCH_TIMEOUT_MS = 60_000;
+const HEARTBEAT_RETRY_INITIAL_DELAY_MS = 250;
+const HEARTBEAT_RETRY_MAX_DELAY_MS = 5_000;
+const HEARTBEAT_RETRY_MAX_ATTEMPTS = 5;
+const HEARTBEAT_RETRY_BACKOFF = 2;
+const HEARTBEAT_RETRY_JITTER = 0.2;
+const STICKY_QUEUE_PREFIX = 'sticky';
+const COMPLETION_COMMAND_TYPES = new Set([
+    CommandType.COMPLETE_WORKFLOW_EXECUTION,
+    CommandType.FAIL_WORKFLOW_EXECUTION,
+    CommandType.CONTINUE_AS_NEW_WORKFLOW_EXECUTION,
+]);
+export class WorkerRuntime {
+    static async create(options = {}) {
+        const config = options.config ?? (await loadTemporalConfig());
+        const dataConverter = options.dataConverter ?? createDefaultDataConverter();
+        const namespace = options.namespace ?? config.namespace;
+        if (!namespace) {
+            throw new Error('Temporal namespace must be provided');
+        }
+        const taskQueue = options.taskQueue ?? config.taskQueue;
+        if (!taskQueue) {
+            throw new Error('Temporal task queue must be provided');
+        }
+        const identity = options.identity ?? config.workerIdentity;
+        const workflows = await loadWorkflows(options.workflowsPath, options.workflows);
+        if (workflows.length === 0) {
+            throw new Error('No workflow definitions were registered; provide workflows or workflowsPath');
+        }
+        const registry = new WorkflowRegistry();
+        registry.registerMany(workflows);
+        const executor = new WorkflowExecutor({
+            registry,
+            dataConverter,
+        });
+        const activities = options.activities ?? {};
+        const observability = await Effect.runPromise(createObservabilityServices({
+            logLevel: config.logLevel,
+            logFormat: config.logFormat,
+            metrics: config.metricsExporter,
+        }, {
+            logger: options.logger,
+            metricsRegistry: options.metrics,
+            metricsExporter: options.metricsExporter,
+        }));
+        const { logger, metricsRegistry, metricsExporter } = observability;
+        const runtimeMetrics = await WorkerRuntime.#initMetrics(metricsRegistry);
+        let workflowService;
+        if (options.workflowService) {
+            workflowService = options.workflowService;
+        }
+        else {
+            const shouldUseTls = Boolean(config.tls || config.allowInsecureTls);
+            const baseUrl = normalizeTemporalAddress(config.address, shouldUseTls);
+            const transport = createGrpcTransport(buildTransportOptions(baseUrl, config));
+            workflowService = createClient(WorkflowService, transport);
+        }
+        const workflowConcurrency = options.concurrency?.workflow ?? config.workerWorkflowConcurrency;
+        const defaultActivityConcurrency = options.concurrency?.activity ?? config.workerActivityConcurrency;
+        const activityConcurrency = defaultActivityConcurrency > 0 ? defaultActivityConcurrency : 1;
+        const workflowPollerCount = options.pollers?.workflow ?? Math.max(1, workflowConcurrency);
+        const scheduler = await Effect.runPromise(makeWorkerScheduler({
+            workflowConcurrency,
+            activityConcurrency,
+            hooks: options.schedulerHooks,
+            logger,
+        }));
+        const stickyCacheCandidate = options.stickyCache;
+        const hasStickyCacheInstance = WorkerRuntime.#isStickyCacheInstance(stickyCacheCandidate);
+        const stickyCacheOptions = hasStickyCacheInstance ? undefined : stickyCacheCandidate;
+        const stickyCacheSize = stickyCacheOptions?.size ?? config.workerStickyCacheSize;
+        const stickyCacheTtlMs = stickyCacheOptions?.ttlMs ?? config.workerStickyTtlMs;
+        const stickyCacheHooks = {
+            onEvict: (entry, reason) => logger.log('debug', 'sticky cache eviction', {
+                namespace: entry.key.namespace,
+                taskQueue,
+                workflowId: entry.key.workflowId,
+                runId: entry.key.runId,
+                workflowType: entry.workflowType,
+                reason,
+            }),
+        };
+        const stickyCache = hasStickyCacheInstance
+            ? stickyCacheCandidate
+            : await Effect.runPromise(makeStickyCache({
+                maxEntries: stickyCacheSize,
+                ttlMs: stickyCacheTtlMs,
+                metrics: {
+                    hits: runtimeMetrics.stickyCacheHit,
+                    misses: runtimeMetrics.stickyCacheMiss,
+                    evictions: runtimeMetrics.stickyCacheEviction,
+                },
+                hooks: stickyCacheHooks,
+            }));
+        const stickyQueue = WorkerRuntime.#buildStickyQueueName(taskQueue, identity);
+        const stickyScheduleToStartTimeoutMs = stickyCacheTtlMs;
+        const stickySchedulingEnabled = options.stickyScheduling ??
+            (config.stickySchedulingEnabled &&
+                (hasStickyCacheInstance ? config.workerStickyCacheSize > 0 : stickyCacheSize > 0));
+        const deploymentName = options.deployment?.name ?? config.workerDeploymentName ?? WorkerRuntime.#defaultDeploymentName(taskQueue);
+        const buildId = options.deployment?.buildId ?? config.workerBuildId ?? identity;
+        const workerVersioningMode = options.deployment?.versioningMode ?? WorkerVersioningMode.UNVERSIONED;
+        const versioningBehavior = workerVersioningMode === WorkerVersioningMode.VERSIONED
+            ? (options.deployment?.versioningBehavior ?? VersioningBehavior.PINNED)
+            : null;
+        const deploymentOptions = create(WorkerDeploymentOptionsSchema, {
+            deploymentName,
+            buildId,
+            workerVersioningMode,
+        });
+        if (workerVersioningMode === WorkerVersioningMode.VERSIONED) {
+            const capability = await checkWorkerVersioningCapability(workflowService, namespace, taskQueue);
+            if (capability.supported) {
+                await registerWorkerBuildIdCompatibility(workflowService, namespace, taskQueue, buildId, { logger });
+            }
+            else {
+                await Effect.runPromise(logger.log('warn', 'skipping worker build ID registration', {
+                    namespace,
+                    taskQueue,
+                    reason: capability.reason ?? 'unknown capability error',
+                    note: 'Temporal CLI dev server (scripts/start-temporal-cli.ts) does not implement worker versioning yet',
+                }));
+            }
+        }
+        const activityLifecycle = await Effect.runPromise(makeActivityLifecycle({
+            heartbeatIntervalMs: config.activityHeartbeatIntervalMs,
+            heartbeatRpcTimeoutMs: config.activityHeartbeatRpcTimeoutMs,
+            heartbeatRetry: {
+                initialIntervalMs: HEARTBEAT_RETRY_INITIAL_DELAY_MS,
+                maxIntervalMs: HEARTBEAT_RETRY_MAX_DELAY_MS,
+                backoffCoefficient: HEARTBEAT_RETRY_BACKOFF,
+                maxAttempts: HEARTBEAT_RETRY_MAX_ATTEMPTS,
+                jitterRatio: HEARTBEAT_RETRY_JITTER,
+            },
+            observability: {
+                logger,
+                heartbeatRetryCounter: runtimeMetrics.heartbeatRetries,
+                heartbeatFailureCounter: runtimeMetrics.heartbeatFailures,
+            },
+        }));
+        await Effect.runPromise(logger.log('info', 'temporal worker runtime configured', {
+            namespace,
+            taskQueue,
+            identity,
+            workflowConcurrency,
+            activityConcurrency,
+            stickySchedulingEnabled,
+            deploymentName,
+            buildId,
+            logLevel: config.logLevel,
+            logFormat: config.logFormat,
+            metricsExporter: config.metricsExporter.type,
+        }));
+        return new WorkerRuntime({
+            config,
+            workflowService,
+            dataConverter,
+            registry,
+            executor,
+            activities,
+            logger,
+            metricsRegistry,
+            metricsExporter,
+            metrics: runtimeMetrics,
+            namespace,
+            taskQueue,
+            identity,
+            activityLifecycle,
+            scheduler,
+            stickyCache,
+            stickyQueue,
+            stickyScheduleToStartTimeoutMs,
+            deploymentOptions,
+            versioningBehavior,
+            stickySchedulingEnabled,
+            workflowPollerCount,
+        });
+    }
+    #config;
+    #workflowService;
+    #dataConverter;
+    #registry;
+    #executor;
+    #activities;
+    #logger;
+    #metricsRegistry;
+    #metrics;
+    #metricsExporter;
+    #namespace;
+    #taskQueue;
+    #identity;
+    #activityLifecycle;
+    #scheduler;
+    #stickyCache;
+    #stickyQueue;
+    #stickySchedulingEnabled;
+    #stickyAttributes;
+    #deploymentOptions;
+    #versioningBehavior;
+    #workflowPollerCount;
+    #running = false;
+    #runFiber = null;
+    #schedulerStarted = false;
+    #schedulerStopPromise = null;
+    constructor(params) {
+        this.#config = params.config;
+        this.#workflowService = params.workflowService;
+        this.#dataConverter = params.dataConverter;
+        this.#registry = params.registry;
+        this.#executor = params.executor;
+        this.#activities = params.activities;
+        this.#logger = params.logger;
+        this.#metricsRegistry = params.metricsRegistry;
+        this.#metrics = params.metrics;
+        this.#metricsExporter = params.metricsExporter;
+        this.#namespace = params.namespace;
+        this.#taskQueue = params.taskQueue;
+        this.#identity = params.identity;
+        this.#activityLifecycle = params.activityLifecycle;
+        this.#scheduler = params.scheduler;
+        this.#stickyCache = params.stickyCache;
+        this.#stickyQueue = params.stickyQueue;
+        this.#stickySchedulingEnabled = params.stickySchedulingEnabled;
+        this.#deploymentOptions = params.deploymentOptions;
+        this.#versioningBehavior = params.versioningBehavior;
+        this.#workflowPollerCount = params.workflowPollerCount;
+        this.#stickyAttributes = create(StickyExecutionAttributesSchema, {
+            workerTaskQueue: create(TaskQueueSchema, { name: this.#stickyQueue }),
+            scheduleToStartTimeout: durationFromMillis(params.stickyScheduleToStartTimeoutMs),
+        });
+    }
+    #isValidDeterminismSnapshot(state) {
+        if (!state) {
+            return false;
+        }
+        return state.commandHistory.length > 0 || state.randomValues.length > 0 || state.timeValues.length > 0;
+    }
+    #resolvePreviousHistoryEventId(response) {
+        const previous = response.previousStartedEventId;
+        if (previous === undefined || previous === null) {
+            return null;
+        }
+        if (typeof previous === 'bigint') {
+            return previous > 0n ? previous.toString() : null;
+        }
+        const numeric = Number(previous);
+        return Number.isFinite(numeric) && numeric > 0 ? numeric.toString() : null;
+    }
+    #resolveCurrentStartedEventId(response) {
+        const started = response.startedEventId;
+        if (started === undefined || started === null) {
+            return null;
+        }
+        if (typeof started === 'bigint') {
+            return started > 0n ? started.toString() : null;
+        }
+        const numeric = Number(started);
+        return Number.isFinite(numeric) && numeric > 0 ? numeric.toString() : null;
+    }
+    static #sanitizeTaskQueueComponent(value) {
+        return value.replace(/[^a-zA-Z0-9_-]/g, '-');
+    }
+    static #buildStickyQueueName(taskQueue, identity) {
+        const queueComponent = WorkerRuntime.#sanitizeTaskQueueComponent(taskQueue);
+        const identityComponent = WorkerRuntime.#sanitizeTaskQueueComponent(identity) || 'worker';
+        return `${queueComponent}-${STICKY_QUEUE_PREFIX}-${identityComponent}`;
+    }
+    static #defaultDeploymentName(taskQueue) {
+        const component = WorkerRuntime.#sanitizeTaskQueueComponent(taskQueue) || 'default';
+        return `${component}-deployment`;
+    }
+    static async #initMetrics(registry) {
+        const makeCounter = (name, description) => Effect.runPromise(registry.counter(name, description));
+        const makeHistogram = (name, description) => Effect.runPromise(registry.histogram(name, description));
+        return {
+            stickyCacheHit: await makeCounter('temporal_worker_sticky_cache_hits_total', 'Sticky cache reuse events'),
+            stickyCacheMiss: await makeCounter('temporal_worker_sticky_cache_misses_total', 'Sticky cache rebuild events'),
+            stickyCacheEviction: await makeCounter('temporal_worker_sticky_cache_evictions_total', 'Sticky cache evictions due to TTL/LRU'),
+            stickyCacheHeal: await makeCounter('temporal_worker_sticky_cache_heal_total', 'Sticky cache entries removed after determinism divergence'),
+            nondeterminism: await makeCounter('temporal_worker_nondeterminism_total', 'Workflow tasks failed because of nondeterminism mismatches'),
+            workflowPollLatency: await makeHistogram('temporal_worker_poll_latency_ms', 'Workflow task poll latency'),
+            activityPollLatency: await makeHistogram('temporal_worker_activity_poll_latency_ms', 'Activity task poll latency'),
+            workflowPollErrors: await makeCounter('temporal_worker_poll_errors_total', 'Workflow polling errors'),
+            activityPollErrors: await makeCounter('temporal_worker_activity_poll_errors_total', 'Activity polling errors'),
+            heartbeatRetries: await makeCounter('temporal_worker_heartbeat_retries_total', 'Activity heartbeat retries'),
+            heartbeatFailures: await makeCounter('temporal_worker_heartbeat_failures_total', 'Activity heartbeat failures'),
+            activityFailures: await makeCounter('temporal_worker_activity_failures_total', 'Activity failures delivered to Temporal'),
+            workflowFailures: await makeCounter('temporal_worker_workflow_failures_total', 'Workflow failure responses sent to Temporal'),
+        };
+    }
+    async run() {
+        if (this.#runFiber) {
+            await this.#awaitRuntimeFiber(this.#runFiber);
+            return;
+        }
+        this.#running = true;
+        const runtimeFiber = Effect.runFork(this.#buildRuntimeEffect());
+        this.#runFiber = runtimeFiber;
+        try {
+            await this.#awaitRuntimeFiber(runtimeFiber);
+        }
+        finally {
+            this.#runFiber = null;
+            this.#running = false;
+        }
+    }
+    async shutdown() {
+        this.#log('info', 'temporal worker shutdown requested', this.#runtimeLogFields({ running: this.#running }));
+        const runtimeFiber = this.#runFiber;
+        if (!runtimeFiber) {
+            await this.#stopScheduler();
+            await this.#flushMetrics();
+            this.#running = false;
+            this.#log('info', 'temporal worker shutdown complete', this.#runtimeLogFields({ drained: false }));
+            return;
+        }
+        await Effect.runPromise(Fiber.interrupt(runtimeFiber));
+        try {
+            await this.#awaitRuntimeFiber(runtimeFiber);
+        }
+        catch {
+            // ignore failures during shutdown; polling loops log errors before exiting
+        }
+        finally {
+            this.#runFiber = null;
+            this.#running = false;
+        }
+        this.#log('info', 'temporal worker shutdown complete', this.#runtimeLogFields({ drained: true }));
+    }
+    #buildRuntimeEffect() {
+        const runtime = this;
+        const workflowPollers = Array.from({ length: runtime.#workflowPollerCount }, () => runtime.#workflowPollerEffect(runtime.#taskQueue));
+        const stickyPollers = runtime.#stickySchedulingEnabled
+            ? Array.from({ length: runtime.#workflowPollerCount }, () => runtime.#workflowPollerEffect(runtime.#stickyQueue))
+            : [];
+        const activityPollers = runtime.#hasActivities() ? [runtime.#activityPollerEffect()] : [];
+        const pollerLoops = [...workflowPollers, ...stickyPollers, ...activityPollers];
+        return Effect.scoped(Effect.gen(function* () {
+            yield* Effect.promise(() => runtime.#startScheduler());
+            runtime.#log('info', 'temporal worker runtime started', runtime.#runtimeLogFields({
+                workflowPollers: runtime.#workflowPollerCount,
+                stickySchedulingEnabled: runtime.#stickySchedulingEnabled,
+            }));
+            if (pollerLoops.length > 0) {
+                yield* Effect.forEach(pollerLoops, (loop) => Effect.forkScoped(loop), { concurrency: 'unbounded' });
+            }
+            yield* Effect.never;
+        })).pipe(Effect.ensuring(Effect.promise(async () => {
+            await runtime.#stopScheduler();
+            await runtime.#flushMetrics();
+            runtime.#log('info', 'temporal worker runtime stopped', runtime.#runtimeLogFields());
+        })));
+    }
+    async #awaitRuntimeFiber(fiber) {
+        const exit = await Effect.runPromiseExit(Fiber.join(fiber));
+        if (Exit.isFailure(exit)) {
+            if (Cause.isInterrupted(exit.cause)) {
+                return;
+            }
+            throw Cause.squash(exit.cause);
+        }
+    }
+    async #startScheduler() {
+        if (this.#schedulerStarted) {
+            return;
+        }
+        await Effect.runPromise(this.#scheduler.start);
+        this.#schedulerStarted = true;
+        this.#log('info', 'worker scheduler started', this.#runtimeLogFields({ stickySchedulingEnabled: this.#stickySchedulingEnabled }));
+    }
+    async #stopScheduler() {
+        if (!this.#schedulerStarted) {
+            return;
+        }
+        if (!this.#schedulerStopPromise) {
+            this.#schedulerStopPromise = Effect.runPromise(this.#scheduler.stop).finally(() => {
+                this.#schedulerStarted = false;
+                this.#schedulerStopPromise = null;
+                this.#log('info', 'worker scheduler stopped', this.#runtimeLogFields());
+            });
+        }
+        await this.#schedulerStopPromise;
+    }
+    #workflowPollerEffect(queueName) {
+        const request = create(PollWorkflowTaskQueueRequestSchema, {
+            namespace: this.#namespace,
+            taskQueue: create(TaskQueueSchema, { name: queueName }),
+            identity: this.#identity,
+            deploymentOptions: this.#deploymentOptions,
+        });
+        const pollOnce = this.#withRpcAbort(async (signal) => {
+            const start = Date.now();
+            const response = await this.#workflowService.pollWorkflowTaskQueue(request, {
+                timeoutMs: POLL_TIMEOUT_MS,
+                signal,
+            });
+            this.#observeHistogram(this.#metrics.workflowPollLatency, Date.now() - start);
+            if (!response.taskToken || response.taskToken.length === 0) {
+                return;
+            }
+            await this.#enqueueWorkflowTask(response);
+        }).pipe(Effect.catchAll((error) => this.#isRpcAbortError(error) ? Effect.void : this.#handleWorkflowPollerError(queueName, error)));
+        return Effect.forever(pollOnce);
+    }
+    async #enqueueWorkflowTask(response) {
+        const taskToken = response.taskToken ?? new Uint8Array();
+        const envelope = {
+            taskToken,
+            execute: () => Effect.promise(async () => {
+                await this.#handleWorkflowTask(response, 0);
+            }),
+        };
+        await Effect.runPromise(this.#scheduler.enqueueWorkflow(envelope));
+    }
+    #activityPollerEffect() {
+        if (!this.#hasActivities()) {
+            return Effect.void;
+        }
+        const request = create(PollActivityTaskQueueRequestSchema, {
+            namespace: this.#namespace,
+            taskQueue: create(TaskQueueSchema, { name: this.#taskQueue }),
+            identity: this.#identity,
+            deploymentOptions: this.#deploymentOptions,
+        });
+        const pollOnce = this.#withRpcAbort(async (signal) => {
+            const start = Date.now();
+            const response = await this.#workflowService.pollActivityTaskQueue(request, {
+                timeoutMs: POLL_TIMEOUT_MS,
+                signal,
+            });
+            this.#observeHistogram(this.#metrics.activityPollLatency, Date.now() - start);
+            if (!response.taskToken || response.taskToken.length === 0) {
+                return;
+            }
+            await this.#enqueueActivityTask(response);
+        }).pipe(Effect.catchAll((error) => (this.#isRpcAbortError(error) ? Effect.void : this.#handleActivityPollerError(error))));
+        return Effect.forever(pollOnce);
+    }
+    #withRpcAbort(run) {
+        return Effect.acquireUseRelease(Effect.sync(() => new AbortController()), (controller) => Effect.tryPromise({
+            try: () => run(controller.signal),
+            catch: (error) => error,
+        }), (controller) => Effect.sync(() => {
+            controller.abort();
+        }));
+    }
+    #isRpcAbortError(error) {
+        return isAbortError(error) || (error instanceof ConnectError && error.code === Code.Canceled);
+    }
+    async #enqueueActivityTask(response) {
+        const taskToken = response.taskToken ?? new Uint8Array();
+        const envelope = {
+            taskToken,
+            handler: () => this.#processActivityTask(response),
+            args: [],
+        };
+        await Effect.runPromise(this.#scheduler.enqueueActivity(envelope));
+    }
+    #handleWorkflowPollerError(queueName, error) {
+        return Effect.promise(async () => {
+            this.#incrementCounter(this.#metrics.workflowPollErrors);
+            this.#log('warn', 'workflow polling failed', {
+                queueName,
+                namespace: this.#namespace,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            await sleep(250);
+        }).pipe(Effect.catchAll(() => Effect.void));
+    }
+    #handleActivityPollerError(error) {
+        return Effect.promise(async () => {
+            this.#incrementCounter(this.#metrics.activityPollErrors);
+            this.#log('warn', 'activity polling failed', {
+                namespace: this.#namespace,
+                taskQueue: this.#taskQueue,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            await sleep(250);
+        }).pipe(Effect.catchAll(() => Effect.void));
+    }
+    async #handleWorkflowTask(response, nondeterminismRetry = 0) {
+        const execution = this.#resolveWorkflowExecution(response);
+        const workflowTaskAttempt = Number(response.attempt ?? 1);
+        const historyEvents = await this.#collectWorkflowHistory(execution, response);
+        const workflowType = this.#resolveWorkflowType(response, historyEvents);
+        const args = await this.#decodeWorkflowArgs(historyEvents);
+        const workflowInfo = this.#buildWorkflowInfo(workflowType, execution);
+        const stickyKey = this.#buildStickyKey(execution.workflowId, execution.runId);
+        const stickyEntry = stickyKey ? await this.#getStickyEntry(stickyKey) : undefined;
+        const historyReplay = await this.#ingestDeterminismState(workflowInfo, historyEvents);
+        const hasHistorySnapshot = this.#isValidDeterminismSnapshot(historyReplay?.determinismState);
+        const baseLogFields = this.#workflowLogFields(execution, workflowType, {
+            workflowTaskAttempt,
+            stickyScheduling: this.#stickySchedulingEnabled,
+            nondeterminismRetry,
+        });
+        let previousState;
+        if (stickyEntry && this.#isValidDeterminismSnapshot(stickyEntry.determinismState)) {
+            const historyBaselineEventId = this.#resolvePreviousHistoryEventId(response) ?? historyReplay?.lastEventId ?? null;
+            const cacheMatchesHistory = (stickyEntry.lastEventId ?? null) === historyBaselineEventId;
+            if (cacheMatchesHistory) {
+                previousState = stickyEntry.determinismState;
+                this.#log('debug', 'sticky cache hit', {
+                    ...baseLogFields,
+                    cacheLastEventId: stickyEntry.lastEventId ?? null,
+                    historyBaselineEventId,
+                });
+                this.#incrementCounter(this.#metrics.stickyCacheHit);
+            }
+            else if (hasHistorySnapshot && historyReplay) {
+                const diff = await Effect.runPromise(diffDeterminismState(stickyEntry.determinismState, historyReplay.determinismState));
+                const logLevel = diff.mismatches.length > 0 ? 'warn' : 'info';
+                this.#log(logLevel, 'sticky cache drift detected', {
+                    ...baseLogFields,
+                    cacheLastEventId: stickyEntry.lastEventId ?? null,
+                    historyBaselineEventId,
+                    mismatches: diff.mismatches,
+                });
+                previousState = historyReplay.determinismState;
+            }
+        }
+        else if (stickyEntry && this.#stickySchedulingEnabled) {
+            this.#log('info', 'sticky cache entry invalid; rebuilding snapshot', {
+                ...baseLogFields,
+                cacheLastEventId: stickyEntry.lastEventId ?? null,
+            });
+        }
+        else if (!stickyEntry && this.#stickySchedulingEnabled) {
+            this.#log('debug', 'sticky cache miss (no entry)', baseLogFields);
+            this.#incrementCounter(this.#metrics.stickyCacheMiss);
+        }
+        if (!previousState && hasHistorySnapshot && historyReplay) {
+            if (this.#stickySchedulingEnabled) {
+                this.#log('debug', 'sticky cache snapshot rebuilt from history', {
+                    ...baseLogFields,
+                    historyBaselineEventId: historyReplay.lastEventId ?? null,
+                });
+            }
+            previousState = historyReplay.determinismState;
+        }
+        const expectedDeterminismState = previousState;
+        try {
+            const activityResults = await this.#extractActivityResolutions(historyEvents);
+            const output = await this.#executor.execute({
+                workflowType,
+                workflowId: execution.workflowId,
+                runId: execution.runId,
+                namespace: this.#namespace,
+                taskQueue: this.#taskQueue,
+                arguments: args,
+                determinismState: previousState,
+                activityResults,
+            });
+            const cacheBaselineEventId = this.#resolveCurrentStartedEventId(response) ?? historyReplay?.lastEventId ?? null;
+            const shouldRecordMarker = output.completion === 'pending';
+            let commandsForResponse = output.commands;
+            if (stickyKey) {
+                if (output.completion === 'pending') {
+                    await this.#upsertStickyEntry(stickyKey, output.determinismState, cacheBaselineEventId, workflowType);
+                    this.#log('debug', 'sticky cache snapshot persisted', {
+                        ...baseLogFields,
+                        cacheBaselineEventId,
+                    });
+                }
+                else {
+                    await this.#removeStickyEntry(stickyKey);
+                    this.#log('debug', 'sticky cache entry cleared (workflow completed)', baseLogFields);
+                }
+            }
+            if (shouldRecordMarker) {
+                const lastEventId = historyReplay?.lastEventId ??
+                    this.#resolveWorkflowHistoryLastEventId(response) ??
+                    stickyEntry?.lastEventId ??
+                    null;
+                const markerDetails = await Effect.runPromise(encodeDeterminismMarkerDetails(this.#dataConverter, {
+                    info: workflowInfo,
+                    determinismState: output.determinismState,
+                    lastEventId,
+                }));
+                const markerCommand = this.#buildDeterminismMarkerCommand(markerDetails);
+                commandsForResponse = this.#injectDeterminismMarker(commandsForResponse, markerCommand);
+            }
+            const completion = create(RespondWorkflowTaskCompletedRequestSchema, {
+                taskToken: response.taskToken,
+                commands: commandsForResponse,
+                identity: this.#identity,
+                namespace: this.#namespace,
+                deploymentOptions: this.#deploymentOptions,
+                ...(this.#stickySchedulingEnabled ? { stickyAttributes: this.#stickyAttributes } : {}),
+                ...(this.#versioningBehavior !== null ? { versioningBehavior: this.#versioningBehavior } : {}),
+            });
+            try {
+                await this.#workflowService.respondWorkflowTaskCompleted(completion, { timeoutMs: RESPOND_TIMEOUT_MS });
+            }
+            catch (rpcError) {
+                if (this.#isTaskNotFoundError(rpcError)) {
+                    this.#logWorkflowTaskNotFound('respondWorkflowTaskCompleted', execution);
+                    return;
+                }
+                throw rpcError;
+            }
+        }
+        catch (error) {
+            let stickyEntryCleared = false;
+            if (stickyKey) {
+                await this.#removeStickyEntry(stickyKey);
+                stickyEntryCleared = true;
+            }
+            if (this.#isTaskNotFoundError(error)) {
+                this.#logWorkflowTaskNotFound('respondWorkflowTaskCompleted', execution);
+                return;
+            }
+            if (error instanceof WorkflowNondeterminismError) {
+                const mismatches = await this.#computeNondeterminismMismatches(error, expectedDeterminismState);
+                if (stickyKey && stickyEntryCleared) {
+                    this.#incrementCounter(this.#metrics.stickyCacheHeal);
+                    this.#log('warn', 'sticky cache entry cleared after nondeterminism', {
+                        ...baseLogFields,
+                        cacheLastEventId: stickyEntry?.lastEventId ?? null,
+                    });
+                }
+                if (nondeterminismRetry === 0) {
+                    this.#log('info', 'retrying workflow task after nondeterminism', {
+                        ...baseLogFields,
+                        mismatches,
+                        retryReason: 'history-refresh',
+                    });
+                    await this.#handleWorkflowTask(response, nondeterminismRetry + 1);
+                    return;
+                }
+                this.#incrementCounter(this.#metrics.nondeterminism);
+                this.#log('error', 'workflow nondeterminism detected', {
+                    ...baseLogFields,
+                    mismatches,
+                });
+                const enriched = this.#augmentNondeterminismError(error, mismatches, {
+                    execution,
+                    workflowType,
+                    stickyLastEventId: stickyEntry?.lastEventId ?? null,
+                    historyLastEventId: historyReplay?.lastEventId ?? null,
+                    workflowTaskAttempt,
+                });
+                await this.#failWorkflowTask(response, execution, enriched, WorkflowTaskFailedCause.NON_DETERMINISTIC_ERROR);
+                return;
+            }
+            if (stickyEntryCleared && this.#stickySchedulingEnabled) {
+                this.#log('debug', 'sticky cache entry cleared after workflow failure', baseLogFields);
+            }
+            await this.#failWorkflowTask(response, execution, error);
+        }
+    }
+    #buildStickyKey(workflowId, runId) {
+        if (!workflowId || !runId) {
+            return null;
+        }
+        return {
+            namespace: this.#namespace,
+            workflowId,
+            runId,
+        };
+    }
+    async #ingestDeterminismState(workflowInfo, historyEvents) {
+        if (historyEvents.length === 0) {
+            return undefined;
+        }
+        return await Effect.runPromise(ingestWorkflowHistory({
+            info: workflowInfo,
+            history: historyEvents,
+            dataConverter: this.#dataConverter,
+        }));
+    }
+    async #collectWorkflowHistory(execution, _response) {
+        const events = [];
+        let token;
+        while (true) {
+            const page = await this.#fetchWorkflowHistoryPage(execution, token);
+            if (page.events.length > 0) {
+                events.push(...page.events);
+            }
+            if (!page.nextPageToken || page.nextPageToken.length === 0) {
+                break;
+            }
+            token = page.nextPageToken;
+        }
+        return events;
+    }
+    async #extractActivityResolutions(events) {
+        const resolutions = new Map();
+        const scheduledActivityIds = new Map();
+        const normalizeEventId = (value) => {
+            if (value === undefined || value === null) {
+                return undefined;
+            }
+            if (typeof value === 'string') {
+                return value;
+            }
+            return value.toString();
+        };
+        const resolveActivityId = (attrs, scheduledEventId) => {
+            const direct = typeof attrs.activityId === 'string' ? attrs.activityId : undefined;
+            if (direct) {
+                return direct;
+            }
+            const key = normalizeEventId(scheduledEventId);
+            if (!key) {
+                return undefined;
+            }
+            return scheduledActivityIds.get(key);
+        };
+        for (const event of events) {
+            switch (event.eventType) {
+                case EventType.ACTIVITY_TASK_SCHEDULED: {
+                    if (event.attributes?.case !== 'activityTaskScheduledEventAttributes') {
+                        break;
+                    }
+                    const activityId = event.attributes.value.activityId;
+                    const scheduledKey = normalizeEventId(event.eventId);
+                    if (activityId && scheduledKey) {
+                        scheduledActivityIds.set(scheduledKey, activityId);
+                    }
+                    break;
+                }
+                case EventType.ACTIVITY_TASK_COMPLETED: {
+                    if (event.attributes?.case !== 'activityTaskCompletedEventAttributes') {
+                        break;
+                    }
+                    const activityId = resolveActivityId(event.attributes.value, event.attributes.value.scheduledEventId);
+                    if (!activityId) {
+                        break;
+                    }
+                    const payloads = event.attributes.value.result?.payloads ?? [];
+                    const decoded = await decodePayloadsToValues(this.#dataConverter, payloads);
+                    const value = decoded.length === 0 ? undefined : decoded.length === 1 ? decoded[0] : Object.freeze([...decoded]);
+                    resolutions.set(activityId, { status: 'completed', value });
+                    break;
+                }
+                case EventType.ACTIVITY_TASK_FAILED: {
+                    if (event.attributes?.case !== 'activityTaskFailedEventAttributes') {
+                        break;
+                    }
+                    const activityId = resolveActivityId(event.attributes.value, event.attributes.value.scheduledEventId);
+                    if (!activityId) {
+                        break;
+                    }
+                    const failureError = (await failureToError(this.#dataConverter, event.attributes.value.failure)) ??
+                        new Error(`Activity ${activityId} failed`);
+                    resolutions.set(activityId, { status: 'failed', error: failureError });
+                    break;
+                }
+                case EventType.ACTIVITY_TASK_TIMED_OUT: {
+                    if (event.attributes?.case !== 'activityTaskTimedOutEventAttributes') {
+                        break;
+                    }
+                    const activityId = resolveActivityId(event.attributes.value, event.attributes.value.scheduledEventId);
+                    if (!activityId) {
+                        break;
+                    }
+                    const timeoutFailure = event.attributes.value.failure?.failureInfo;
+                    const timeoutTypeValue = timeoutFailure?.case === 'timeoutFailureInfo' ? timeoutFailure.value.timeoutType : undefined;
+                    const timeoutType = timeoutTypeValue !== undefined ? (TimeoutType[timeoutTypeValue] ?? String(timeoutTypeValue)) : 'unknown';
+                    const failureError = (await failureToError(this.#dataConverter, event.attributes.value.failure)) ??
+                        new Error(`Activity ${activityId} timed out (${timeoutType})`);
+                    resolutions.set(activityId, { status: 'failed', error: failureError });
+                    break;
+                }
+                case EventType.ACTIVITY_TASK_CANCELED: {
+                    if (event.attributes?.case !== 'activityTaskCanceledEventAttributes') {
+                        break;
+                    }
+                    const activityId = resolveActivityId(event.attributes.value, event.attributes.value.scheduledEventId);
+                    if (!activityId) {
+                        break;
+                    }
+                    const details = await decodePayloadsToValues(this.#dataConverter, event.attributes.value.details?.payloads ?? []);
+                    const error = new Error(`Activity ${activityId} was canceled`);
+                    error.details = details;
+                    resolutions.set(activityId, { status: 'failed', error });
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+        return resolutions;
+    }
+    async #fetchWorkflowHistoryPage(execution, nextPageToken) {
+        if (!execution.workflowId || !execution.runId) {
+            return { events: [], nextPageToken: new Uint8Array() };
+        }
+        const historyRequest = create(GetWorkflowExecutionHistoryRequestSchema, {
+            namespace: this.#namespace,
+            execution: create(WorkflowExecutionSchema, {
+                workflowId: execution.workflowId,
+                runId: execution.runId,
+            }),
+            maximumPageSize: 0,
+            ...(nextPageToken && nextPageToken.length > 0 ? { nextPageToken } : {}),
+            waitNewEvent: false,
+            historyEventFilterType: HistoryEventFilterType.ALL_EVENT,
+            skipArchival: true,
+        });
+        const historyResponse = await this.#workflowService.getWorkflowExecutionHistory(historyRequest, {
+            timeoutMs: HISTORY_FETCH_TIMEOUT_MS,
+        });
+        return {
+            events: historyResponse.history?.events ?? [],
+            nextPageToken: historyResponse.nextPageToken ?? new Uint8Array(),
+        };
+    }
+    #buildWorkflowInfo(workflowType, execution) {
+        return {
+            namespace: this.#namespace,
+            taskQueue: this.#taskQueue,
+            workflowId: execution.workflowId,
+            runId: execution.runId,
+            workflowType,
+        };
+    }
+    async #getStickyEntry(key) {
+        return await Effect.runPromise(this.#stickyCache.get(key));
+    }
+    async #upsertStickyEntry(key, state, lastEventId, workflowType) {
+        const entry = {
+            key,
+            determinismState: state,
+            lastEventId,
+            lastAccessed: Date.now(),
+            workflowType,
+        };
+        await Effect.runPromise(this.#stickyCache.upsert(entry));
+    }
+    #resolveWorkflowHistoryLastEventId(response) {
+        return resolveHistoryLastEventId(response.history?.events ?? []);
+    }
+    #isTaskNotFoundError(error) {
+        return error instanceof ConnectError && error.code === Code.NotFound;
+    }
+    #buildDeterminismMarkerCommand(details) {
+        return create(CommandSchema, {
+            commandType: CommandType.RECORD_MARKER,
+            attributes: {
+                case: 'recordMarkerCommandAttributes',
+                value: create(RecordMarkerCommandAttributesSchema, {
+                    markerName: DETERMINISM_MARKER_NAME,
+                    details,
+                }),
+            },
+        });
+    }
+    #injectDeterminismMarker(commands, marker) {
+        if (commands.some((command) => this.#isDeterminismMarkerCommand(command))) {
+            return commands;
+        }
+        const next = [...commands];
+        const completionIndex = next.findIndex((command) => COMPLETION_COMMAND_TYPES.has(command.commandType));
+        if (completionIndex === -1) {
+            next.push(marker);
+            return next;
+        }
+        next.splice(completionIndex, 0, marker);
+        return next;
+    }
+    #isDeterminismMarkerCommand(command) {
+        if (command.commandType !== CommandType.RECORD_MARKER) {
+            return false;
+        }
+        if (command.attributes?.case !== 'recordMarkerCommandAttributes') {
+            return false;
+        }
+        return command.attributes.value.markerName === DETERMINISM_MARKER_NAME;
+    }
+    #log(level, message, fields) {
+        void Effect.runPromise(this.#logger.log(level, message, fields));
+    }
+    #incrementCounter(counter, value = 1) {
+        void Effect.runPromise(counter.inc(value));
+    }
+    #observeHistogram(histogram, value) {
+        void Effect.runPromise(histogram.observe(value));
+    }
+    #workflowLogFields(execution, workflowType, extra) {
+        return {
+            namespace: this.#namespace,
+            taskQueue: this.#taskQueue,
+            workflowId: execution.workflowId,
+            runId: execution.runId,
+            workflowType,
+            ...(extra ?? {}),
+        };
+    }
+    #runtimeLogFields(extra) {
+        return {
+            namespace: this.#namespace,
+            taskQueue: this.#taskQueue,
+            identity: this.#identity,
+            ...(extra ?? {}),
+        };
+    }
+    async #computeNondeterminismMismatches(error, expectedState) {
+        const baseline = expectedState ?? {
+            commandHistory: [],
+            randomValues: [],
+            timeValues: [],
+            failureMetadata: undefined,
+        };
+        const hint = error.details?.hint;
+        if (!hint) {
+            return [];
+        }
+        const commandIndex = this.#parseIndexFromHint(hint, 'commandIndex');
+        const randomIndex = this.#parseIndexFromHint(hint, 'randomIndex');
+        const timeIndex = this.#parseIndexFromHint(hint, 'timeIndex');
+        const mutableActual = {
+            commandHistory: baseline.commandHistory.map((entry) => ({
+                intent: entry.intent,
+                metadata: entry.metadata ? { ...entry.metadata } : undefined,
+            })),
+            randomValues: [...baseline.randomValues],
+            timeValues: [...baseline.timeValues],
+            failureMetadata: baseline.failureMetadata ? { ...baseline.failureMetadata } : undefined,
+        };
+        let mutated = false;
+        if (commandIndex !== null) {
+            const received = error.details?.received;
+            if (received) {
+                if (commandIndex < mutableActual.commandHistory.length) {
+                    mutableActual.commandHistory = mutableActual.commandHistory.map((entry, idx) => idx === commandIndex ? { intent: received, metadata: entry.metadata } : entry);
+                }
+                else {
+                    mutableActual.commandHistory = [...mutableActual.commandHistory, { intent: received }];
+                }
+                mutated = true;
+            }
+            else if (commandIndex < mutableActual.commandHistory.length) {
+                mutableActual.commandHistory = mutableActual.commandHistory.filter((_, idx) => idx !== commandIndex);
+                mutated = true;
+            }
+        }
+        if (randomIndex !== null) {
+            this.#ensureArrayLength(mutableActual.randomValues, randomIndex);
+            mutableActual.randomValues[randomIndex] = Number.NaN;
+            mutated = true;
+        }
+        if (timeIndex !== null) {
+            this.#ensureArrayLength(mutableActual.timeValues, timeIndex);
+            mutableActual.timeValues[timeIndex] = Number.NaN;
+            mutated = true;
+        }
+        if (!mutated) {
+            return [];
+        }
+        const actualState = {
+            commandHistory: mutableActual.commandHistory,
+            randomValues: mutableActual.randomValues,
+            timeValues: mutableActual.timeValues,
+            failureMetadata: mutableActual.failureMetadata,
+        };
+        const diff = await Effect.runPromise(diffDeterminismState(baseline, actualState));
+        return diff.mismatches;
+    }
+    #augmentNondeterminismError(error, mismatches, context) {
+        if (mismatches.length === 0) {
+            return error;
+        }
+        const details = {
+            ...(error.details ?? {}),
+            mismatches,
+            workflow: {
+                namespace: this.#namespace,
+                taskQueue: this.#taskQueue,
+                workflowId: context.execution.workflowId,
+                runId: context.execution.runId,
+                workflowType: context.workflowType,
+            },
+            workflowTaskAttempt: context.workflowTaskAttempt,
+            stickyCache: {
+                cachedEventId: context.stickyLastEventId ?? undefined,
+                historyLastEventId: context.historyLastEventId ?? undefined,
+            },
+        };
+        const enriched = new WorkflowNondeterminismError(error.message, details);
+        enriched.stack = error.stack;
+        return enriched;
+    }
+    #parseIndexFromHint(hint, label) {
+        const pattern = new RegExp(`${label}=(\\d+)`);
+        const match = pattern.exec(hint);
+        if (!match) {
+            return null;
+        }
+        const value = Number.parseInt(match[1] ?? '', 10);
+        return Number.isNaN(value) ? null : value;
+    }
+    #ensureArrayLength(array, index) {
+        while (array.length <= index) {
+            array.push(Number.NaN);
+        }
+    }
+    static #isStickyCacheInstance(value) {
+        if (!value || typeof value !== 'object') {
+            return false;
+        }
+        const candidate = value;
+        return (typeof candidate.upsert === 'function' &&
+            typeof candidate.get === 'function' &&
+            typeof candidate.remove === 'function');
+    }
+    async #removeStickyEntry(key) {
+        await Effect.runPromise(this.#stickyCache.remove(key));
+    }
+    async #failWorkflowTask(response, execution, error, cause = WorkflowTaskFailedCause.UNSPECIFIED) {
+        const failure = await encodeErrorToFailure(this.#dataConverter, error);
+        const encoded = await encodeFailurePayloads(this.#dataConverter, failure);
+        const failed = create(RespondWorkflowTaskFailedRequestSchema, {
+            taskToken: response.taskToken,
+            cause,
+            failure: encoded,
+            identity: this.#identity,
+            namespace: this.#namespace,
+            deploymentOptions: this.#deploymentOptions,
+        });
+        try {
+            await this.#workflowService.respondWorkflowTaskFailed(failed, { timeoutMs: RESPOND_TIMEOUT_MS });
+            this.#incrementCounter(this.#metrics.workflowFailures);
+        }
+        catch (rpcError) {
+            if (this.#isTaskNotFoundError(rpcError)) {
+                this.#logWorkflowTaskNotFound('respondWorkflowTaskFailed', execution);
+                return;
+            }
+            throw rpcError;
+        }
+    }
+    async #processActivityTask(response) {
+        const cancelRequested = isActivityCancelRequested(response);
+        if (cancelRequested) {
+            await this.#cancelActivityTask(response);
+            return;
+        }
+        const taskToken = response.taskToken;
+        if (!taskToken || taskToken.length === 0) {
+            await this.#failActivityTask(response, new Error('Activity task missing token'));
+            return;
+        }
+        const activityType = response.activityType?.name;
+        if (!activityType) {
+            await this.#failActivityTask(response, new Error('Activity task missing type'));
+            return;
+        }
+        const handler = this.#activities[activityType];
+        if (!handler) {
+            await this.#failActivityTask(response, new Error(`No handler registered for activity ${activityType}`));
+            return;
+        }
+        const args = await decodePayloadsToValues(this.#dataConverter, response.input?.payloads ?? []);
+        const heartbeatDetails = await decodePayloadsToValues(this.#dataConverter, response.heartbeatDetails?.payloads ?? []);
+        const { context, abortController } = this.#createActivityContext(response, cancelRequested, heartbeatDetails);
+        let heartbeatRegistration;
+        try {
+            heartbeatRegistration = await Effect.runPromise(this.#activityLifecycle.registerHeartbeat({
+                context,
+                workflowService: this.#workflowService,
+                taskToken,
+                identity: this.#identity,
+                namespace: this.#namespace,
+                dataConverter: this.#dataConverter,
+                abortController,
+            }));
+            context.heartbeat = async (...details) => {
+                context.info.lastHeartbeatDetails = details;
+                const registration = heartbeatRegistration;
+                if (!registration) {
+                    return;
+                }
+                await Effect.runPromise(registration.heartbeat(details));
+            };
+        }
+        catch (registrationError) {
+            this.#log('warn', 'failed to register heartbeat handler', {
+                activityType,
+                workflowId: context.info.workflowId,
+                runId: context.info.runId,
+                error: registrationError instanceof Error ? registrationError.message : String(registrationError),
+            });
+            context.heartbeat = async (...details) => {
+                context.info.lastHeartbeatDetails = details;
+            };
+        }
+        const retryPolicy = this.#convertRetryPolicy(response.retryPolicy);
+        const retryDeadlineMs = this.#computeRetryDeadline(response);
+        let retryState = {
+            attempt: context.info.attempt,
+            retryCount: 0,
+            nextDelayMs: 0,
+        };
+        try {
+            while (true) {
+                try {
+                    const result = await runWithActivityContext(context, async () => await handler(...args));
+                    const payloads = await encodeValuesToPayloads(this.#dataConverter, result === undefined ? [] : [result]);
+                    const completion = create(RespondActivityTaskCompletedRequestSchema, {
+                        taskToken: response.taskToken,
+                        identity: this.#identity,
+                        namespace: this.#namespace,
+                        result: payloads && payloads.length > 0 ? create(PayloadsSchema, { payloads }) : undefined,
+                        deploymentOptions: this.#deploymentOptions,
+                    });
+                    await this.#workflowService.respondActivityTaskCompleted(completion, { timeoutMs: RESPOND_TIMEOUT_MS });
+                    break;
+                }
+                catch (error) {
+                    if (isAbortError(error)) {
+                        await this.#cancelActivityTask(response, context);
+                        return;
+                    }
+                    if (!retryPolicy || this.#isNonRetryableActivityError(error, retryPolicy)) {
+                        await this.#failActivityTask(response, error, context);
+                        return;
+                    }
+                    const nextRetry = await Effect.runPromise(this.#activityLifecycle.nextRetryDelay(retryPolicy, retryState));
+                    if (!nextRetry) {
+                        markErrorNonRetryable(error);
+                        await this.#failActivityTask(response, error, context);
+                        return;
+                    }
+                    if (retryDeadlineMs !== undefined && Date.now() + nextRetry.nextDelayMs > retryDeadlineMs) {
+                        markErrorNonRetryable(error);
+                        await this.#failActivityTask(response, error, context);
+                        return;
+                    }
+                    await sleep(nextRetry.nextDelayMs);
+                    context.throwIfCancelled();
+                    context.info.attempt = nextRetry.attempt;
+                    retryState = nextRetry;
+                }
+            }
+        }
+        finally {
+            if (heartbeatRegistration) {
+                try {
+                    await Effect.runPromise(heartbeatRegistration.shutdown);
+                }
+                catch (shutdownError) {
+                    this.#log('warn', 'heartbeat shutdown failed', {
+                        activityType,
+                        error: shutdownError instanceof Error ? shutdownError.message : String(shutdownError),
+                    });
+                }
+            }
+        }
+    }
+    async #failActivityTask(response, error, context) {
+        const failure = await encodeErrorToFailure(this.#dataConverter, error);
+        const encoded = await encodeFailurePayloads(this.#dataConverter, failure);
+        const lastHeartbeatDetails = await this.#encodeHeartbeatPayloads(context?.info.lastHeartbeatDetails, context?.info.cancellationReason);
+        const request = create(RespondActivityTaskFailedRequestSchema, {
+            taskToken: response.taskToken,
+            identity: this.#identity,
+            namespace: this.#namespace,
+            failure: encoded,
+            lastHeartbeatDetails,
+            deploymentOptions: this.#deploymentOptions,
+        });
+        await this.#workflowService.respondActivityTaskFailed(request, { timeoutMs: RESPOND_TIMEOUT_MS });
+        this.#incrementCounter(this.#metrics.activityFailures);
+    }
+    async #cancelActivityTask(response, context) {
+        const details = await this.#encodeHeartbeatPayloads(context?.info.lastHeartbeatDetails, context?.info.cancellationReason);
+        const request = create(RespondActivityTaskCanceledRequestSchema, {
+            taskToken: response.taskToken,
+            identity: this.#identity,
+            namespace: this.#namespace,
+            details,
+            deploymentOptions: this.#deploymentOptions,
+        });
+        await this.#workflowService.respondActivityTaskCanceled(request, { timeoutMs: RESPOND_TIMEOUT_MS });
+    }
+    async #encodeHeartbeatPayloads(details, reason) {
+        const finalDetails = details && details.length > 0
+            ? details
+            : reason
+                ? [
+                    {
+                        cancellationReason: reason,
+                    },
+                ]
+                : undefined;
+        if (!finalDetails) {
+            return undefined;
+        }
+        const payloads = await encodeValuesToPayloads(this.#dataConverter, finalDetails);
+        return payloads.length > 0 ? create(PayloadsSchema, { payloads }) : undefined;
+    }
+    #createActivityContext(response, cancelRequested, lastHeartbeatDetails) {
+        const abortController = new AbortController();
+        if (cancelRequested) {
+            abortController.abort(createActivityAbortError('Activity cancellation requested by Temporal'));
+        }
+        const info = {
+            activityId: response.activityId ?? '',
+            activityType: response.activityType?.name ?? '',
+            workflowNamespace: response.workflowNamespace ?? this.#namespace,
+            workflowType: response.workflowType?.name ?? '',
+            workflowId: response.workflowExecution?.workflowId ?? '',
+            runId: response.workflowExecution?.runId ?? '',
+            taskQueue: this.#taskQueue,
+            attempt: Number(response.attempt ?? 1),
+            isLocal: false,
+            scheduledTime: timestampToDate(response.scheduledTime),
+            startedTime: timestampToDate(response.startedTime),
+            currentAttemptScheduledTime: timestampToDate(response.currentAttemptScheduledTime),
+            heartbeatTimeoutMs: durationToMillis(response.heartbeatTimeout),
+            scheduleToCloseTimeoutMs: durationToMillis(response.scheduleToCloseTimeout),
+            startToCloseTimeoutMs: durationToMillis(response.startToCloseTimeout),
+            lastHeartbeatDetails,
+            lastHeartbeatTime: undefined,
+            cancellationReason: cancelRequested ? 'poll-cancel-requested' : undefined,
+        };
+        const context = {
+            info,
+            cancellationSignal: abortController.signal,
+            get isCancellationRequested() {
+                return abortController.signal.aborted;
+            },
+            async heartbeat(...details) {
+                info.lastHeartbeatDetails = details;
+            },
+            throwIfCancelled() {
+                if (!abortController.signal.aborted) {
+                    return;
+                }
+                const reason = abortController.signal.reason;
+                if (reason instanceof Error) {
+                    throw reason;
+                }
+                const error = createActivityAbortError(typeof reason === 'string' && reason.length > 0 ? reason : 'Activity cancelled by Temporal');
+                throw error;
+            },
+        };
+        return { context, abortController };
+    }
+    #convertRetryPolicy(policy) {
+        if (!policy) {
+            return undefined;
+        }
+        const initialIntervalMs = durationToMillis(policy.initialInterval);
+        const maximumIntervalMs = durationToMillis(policy.maximumInterval);
+        const backoffCoefficient = policy.backoffCoefficient !== 0 ? policy.backoffCoefficient : undefined;
+        const maximumAttempts = policy.maximumAttempts > 0 ? policy.maximumAttempts : undefined;
+        const nonRetryable = policy.nonRetryableErrorTypes.length > 0 ? [...policy.nonRetryableErrorTypes] : undefined;
+        if (initialIntervalMs === undefined &&
+            maximumIntervalMs === undefined &&
+            backoffCoefficient === undefined &&
+            maximumAttempts === undefined &&
+            (nonRetryable === undefined || nonRetryable.length === 0)) {
+            return undefined;
+        }
+        return {
+            ...(initialIntervalMs !== undefined ? { initialIntervalMs } : {}),
+            ...(backoffCoefficient !== undefined ? { backoffCoefficient } : {}),
+            ...(maximumIntervalMs !== undefined ? { maximumIntervalMs } : {}),
+            ...(maximumAttempts !== undefined ? { maximumAttempts } : {}),
+            ...(nonRetryable !== undefined ? { nonRetryableErrorTypes: nonRetryable } : {}),
+        };
+    }
+    #isNonRetryableActivityError(error, retry) {
+        if (error && typeof error === 'object' && error.nonRetryable === true) {
+            return true;
+        }
+        const errorName = error instanceof Error ? error.name : undefined;
+        if (!errorName) {
+            return false;
+        }
+        return Boolean(retry.nonRetryableErrorTypes?.includes(errorName));
+    }
+    #computeRetryDeadline(response) {
+        const scheduleToClose = durationToMillis(response.scheduleToCloseTimeout);
+        const startToClose = durationToMillis(response.startToCloseTimeout);
+        const scheduledTime = timestampToDate(response.scheduledTime);
+        const startedTime = timestampToDate(response.startedTime) ?? scheduledTime;
+        const scheduleDeadline = scheduleToClose && scheduledTime ? scheduledTime.getTime() + scheduleToClose : undefined;
+        const startDeadline = startToClose && startedTime ? startedTime.getTime() + startToClose : undefined;
+        if (scheduleDeadline && startDeadline) {
+            return Math.min(scheduleDeadline, startDeadline);
+        }
+        return scheduleDeadline ?? startDeadline ?? undefined;
+    }
+    async #flushMetrics() {
+        try {
+            await Effect.runPromise(this.#metricsExporter.flush());
+        }
+        catch (error) {
+            this.#log('warn', 'failed to flush metrics exporter', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async #decodeWorkflowArgs(events) {
+        const startEvent = this.#findWorkflowStartedEvent(events);
+        if (!startEvent) {
+            return [];
+        }
+        const attributes = startEvent.attributes?.case === 'workflowExecutionStartedEventAttributes'
+            ? startEvent.attributes.value
+            : undefined;
+        if (!attributes) {
+            return [];
+        }
+        const inputPayloads = attributes.input?.payloads ?? [];
+        return await decodePayloadsToValues(this.#dataConverter, inputPayloads);
+    }
+    #resolveWorkflowType(response, events) {
+        if (response.workflowType?.name) {
+            return response.workflowType.name;
+        }
+        const startEvent = this.#findWorkflowStartedEvent(events);
+        if (startEvent?.attributes?.case === 'workflowExecutionStartedEventAttributes') {
+            const workflowTypeName = startEvent.attributes.value.workflowType?.name;
+            if (workflowTypeName) {
+                return workflowTypeName;
+            }
+        }
+        throw new Error('Unable to resolve workflow type from workflow task');
+    }
+    #resolveWorkflowExecution(response) {
+        const workflowId = response.workflowExecution?.workflowId ?? '';
+        const runId = response.workflowExecution?.runId ?? '';
+        return { workflowId, runId };
+    }
+    #findWorkflowStartedEvent(events) {
+        return events.find((event) => event.eventType === EventType.WORKFLOW_EXECUTION_STARTED &&
+            event.attributes?.case === 'workflowExecutionStartedEventAttributes');
+    }
+    #hasActivities() {
+        return Object.keys(this.#activities).length > 0;
+    }
+    #logWorkflowTaskNotFound(context, execution) {
+        this.#log('warn', 'workflow task already resolved', {
+            context,
+            workflowId: execution.workflowId,
+            runId: execution.runId,
+        });
+    }
+}
+const timestampToDate = (timestamp) => {
+    if (!timestamp) {
+        return undefined;
+    }
+    const seconds = Number(timestamp.seconds ?? 0n);
+    const nanos = timestamp.nanos ?? 0;
+    return new Date(seconds * 1000 + Math.trunc(nanos / 1_000_000));
+};
+const createActivityAbortError = (message) => {
+    const error = new Error(message);
+    error.name = 'AbortError';
+    return error;
+};
+const markErrorNonRetryable = (error) => {
+    if (error && typeof error === 'object') {
+        ;
+        error.nonRetryable = true;
+    }
+};
+const isActivityCancelRequested = (response) => Boolean(response.cancelRequested);
+const isAbortError = (error) => error instanceof Error && error.name === 'AbortError';
+async function loadWorkflows(workflowsPath, overrides) {
+    if (overrides && overrides.length > 0) {
+        return [...overrides];
+    }
+    if (!workflowsPath) {
+        return [];
+    }
+    const moduleUrl = pathToFileURL(workflowsPath);
+    const loaded = await import(moduleUrl.href);
+    const exported = (loaded.workflows ?? loaded.default);
+    if (Array.isArray(exported)) {
+        return exported;
+    }
+    return [];
+}
+//# sourceMappingURL=runtime.js.map