@proompteng/temporal-bun-sdk 0.2.0 → 0.4.0

package/dist/src/worker/runtime.js

@@ -6,10 +6,11 @@ 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 { buildCodecsFromConfig, 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 { makeDefaultWorkerInterceptors, runWorkerInterceptors, } from '../interceptors/worker';
 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';
@@ -18,9 +19,10 @@ 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 { QueryResultType } from '../proto/temporal/api/enums/v1/query_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 { GetWorkflowExecutionHistoryRequestSchema, PollActivityTaskQueueRequestSchema, PollWorkflowTaskQueueRequestSchema, RespondActivityTaskCanceledRequestSchema, RespondActivityTaskCompletedRequestSchema, RespondActivityTaskFailedRequestSchema, RespondQueryTaskCompletedRequestSchema, 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';
@@ -30,6 +32,24 @@ import { runWithActivityContext } from './activity-context';
 import { checkWorkerVersioningCapability, registerWorkerBuildIdCompatibility } from './build-id';
 import { makeWorkerScheduler, } from './concurrency';
 import { makeStickyCache, } from './sticky-cache';
+import { buildUpdateProtocolMessages, collectWorkflowUpdates } from './update-protocol';
+const mergeUpdateInvocations = (historyInvocations, messageInvocations) => {
+    const merged = [];
+    const seen = new Set();
+    for (const invocation of historyInvocations ?? []) {
+        if (!seen.has(invocation.updateId)) {
+            merged.push(invocation);
+            seen.add(invocation.updateId);
+        }
+    }
+    for (const invocation of messageInvocations ?? []) {
+        if (!seen.has(invocation.updateId)) {
+            merged.push(invocation);
+            seen.add(invocation.updateId);
+        }
+    }
+    return merged;
+};
 const POLL_TIMEOUT_MS = 60_000;
 const RESPOND_TIMEOUT_MS = 15_000;
 const HISTORY_FETCH_TIMEOUT_MS = 60_000;
@@ -47,7 +67,6 @@ const COMPLETION_COMMAND_TYPES = new Set([
 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');
@@ -61,12 +80,6 @@ export class WorkerRuntime {
         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,
@@ -78,6 +91,18 @@ export class WorkerRuntime {
             metricsExporter: options.metricsExporter,
         }));
         const { logger, metricsRegistry, metricsExporter } = observability;
+        const dataConverter = options.dataConverter ??
+            createDefaultDataConverter({
+                payloadCodecs: buildCodecsFromConfig(config.payloadCodecs),
+                logger,
+                metricsRegistry,
+            });
+        const registry = new WorkflowRegistry();
+        registry.registerMany(workflows);
+        const executor = new WorkflowExecutor({
+            registry,
+            dataConverter,
+        });
         const runtimeMetrics = await WorkerRuntime.#initMetrics(metricsRegistry);
         let workflowService;
         if (options.workflowService) {
@@ -98,6 +123,12 @@ export class WorkerRuntime {
             activityConcurrency,
             hooks: options.schedulerHooks,
             logger,
+            metrics: {
+                workflowTaskStarted: runtimeMetrics.workflowTaskStarted,
+                workflowTaskCompleted: runtimeMetrics.workflowTaskCompleted,
+                activityTaskStarted: runtimeMetrics.activityTaskStarted,
+                activityTaskCompleted: runtimeMetrics.activityTaskCompleted,
+            },
         }));
         const stickyCacheCandidate = options.stickyCache;
         const hasStickyCacheInstance = WorkerRuntime.#isStickyCacheInstance(stickyCacheCandidate);
@@ -156,6 +187,22 @@ export class WorkerRuntime {
                 }));
             }
         }
+        const tracingEnabled = options.tracingEnabled ?? config.tracingInterceptorsEnabled ?? false;
+        const workerInterceptorBuilder = options.interceptorBuilder ?? {
+            build: (input) => makeDefaultWorkerInterceptors(input),
+        };
+        const defaultWorkerInterceptors = await Effect.runPromise(workerInterceptorBuilder.build({
+            namespace,
+            taskQueue,
+            identity,
+            buildId,
+            logger,
+            metricsRegistry,
+            metricsExporter,
+            dataConverter,
+            tracingEnabled,
+        }));
+        const workerInterceptors = [...defaultWorkerInterceptors, ...(options.interceptors ?? [])];
         const activityLifecycle = await Effect.runPromise(makeActivityLifecycle({
             heartbeatIntervalMs: config.activityHeartbeatIntervalMs,
             heartbeatRpcTimeoutMs: config.activityHeartbeatRpcTimeoutMs,
@@ -208,6 +255,7 @@ export class WorkerRuntime {
             versioningBehavior,
             stickySchedulingEnabled,
             workflowPollerCount,
+            interceptors: workerInterceptors,
         });
     }
     #config;
@@ -223,6 +271,7 @@ export class WorkerRuntime {
     #namespace;
     #taskQueue;
     #identity;
+    #interceptors;
     #activityLifecycle;
     #scheduler;
     #stickyCache;
@@ -250,6 +299,7 @@ export class WorkerRuntime {
         this.#namespace = params.namespace;
         this.#taskQueue = params.taskQueue;
         this.#identity = params.identity;
+        this.#interceptors = params.interceptors;
         this.#activityLifecycle = params.activityLifecycle;
         this.#scheduler = params.scheduler;
         this.#stickyCache = params.stickyCache;
@@ -267,7 +317,11 @@ export class WorkerRuntime {
         if (!state) {
             return false;
         }
-        return state.commandHistory.length > 0 || state.randomValues.length > 0 || state.timeValues.length > 0;
+        return (state.commandHistory.length > 0 ||
+            state.randomValues.length > 0 ||
+            state.timeValues.length > 0 ||
+            (state.signals?.length ?? 0) > 0 ||
+            (state.queries?.length ?? 0) > 0);
     }
     #resolvePreviousHistoryEventId(response) {
         const previous = response.previousStartedEventId;
@@ -320,6 +374,14 @@ export class WorkerRuntime {
             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'),
+            workflowTaskStarted: await makeCounter('temporal_worker_workflow_tasks_started_total', 'Workflow tasks dispatched to the scheduler'),
+            workflowTaskCompleted: await makeCounter('temporal_worker_workflow_tasks_completed_total', 'Workflow tasks completed by the scheduler'),
+            activityTaskStarted: await makeCounter('temporal_worker_activity_tasks_started_total', 'Activity tasks dispatched to the scheduler'),
+            activityTaskCompleted: await makeCounter('temporal_worker_activity_tasks_completed_total', 'Activity tasks completed by the scheduler'),
+            queryTaskStarted: await makeCounter('temporal_worker_query_started_total', 'Query-only workflow tasks dispatched to the scheduler'),
+            queryTaskCompleted: await makeCounter('temporal_worker_query_completed_total', 'Query-only workflow tasks completed successfully'),
+            queryTaskFailed: await makeCounter('temporal_worker_query_failed_total', 'Query-only workflow tasks responded with failure'),
+            queryTaskLatency: await makeHistogram('temporal_worker_query_latency_ms', 'End-to-end workflow query latency (ms)'),
         };
     }
     async run() {
@@ -481,17 +543,38 @@ export class WorkerRuntime {
     #isRpcAbortError(error) {
         return isAbortError(error) || (error instanceof ConnectError && error.code === Code.Canceled);
     }
+    #isBenignPollTimeout(error) {
+        if (error instanceof ConnectError) {
+            return error.code === Code.DeadlineExceeded || error.code === Code.Canceled;
+        }
+        if (error instanceof Error) {
+            const msg = error.message.toLowerCase();
+            return msg.includes('deadline') && msg.includes('exceeded');
+        }
+        if (typeof error === 'string') {
+            const msg = error.toLowerCase();
+            return msg.includes('deadline') && msg.includes('exceeded');
+        }
+        return false;
+    }
     async #enqueueActivityTask(response) {
         const taskToken = response.taskToken ?? new Uint8Array();
         const envelope = {
             taskToken,
-            handler: () => this.#processActivityTask(response),
+            handler: () => this.#runActivityTask(response),
             args: [],
         };
         await Effect.runPromise(this.#scheduler.enqueueActivity(envelope));
     }
     #handleWorkflowPollerError(queueName, error) {
         return Effect.promise(async () => {
+            if (this.#isBenignPollTimeout(error)) {
+                this.#log('debug', 'workflow poll timeout (no tasks)', {
+                    queueName,
+                    namespace: this.#namespace,
+                });
+                return;
+            }
             this.#incrementCounter(this.#metrics.workflowPollErrors);
             this.#log('warn', 'workflow polling failed', {
                 queueName,
@@ -503,6 +586,13 @@ export class WorkerRuntime {
     }
     #handleActivityPollerError(error) {
         return Effect.promise(async () => {
+            if (this.#isBenignPollTimeout(error)) {
+                this.#log('debug', 'activity poll timeout (no tasks)', {
+                    namespace: this.#namespace,
+                    taskQueue: this.#taskQueue,
+                });
+                return;
+            }
             this.#incrementCounter(this.#metrics.activityPollErrors);
             this.#log('warn', 'activity polling failed', {
                 namespace: this.#namespace,
@@ -514,20 +604,83 @@ export class WorkerRuntime {
     }
     async #handleWorkflowTask(response, nondeterminismRetry = 0) {
         const execution = this.#resolveWorkflowExecution(response);
+        const queryCount = response.queries && typeof response.queries === 'object' && !Array.isArray(response.queries)
+            ? Object.keys(response.queries).length
+            : Array.isArray(response.queries)
+                ? response.queries.length
+                : 0;
+        const hasQueryRequests = Boolean(response.query) || queryCount > 0;
+        const hasUpdateMessages = (response.messages?.length ?? 0) > 0;
+        const kind = hasUpdateMessages
+            ? 'worker.updateTask'
+            : hasQueryRequests
+                ? 'worker.queryTask'
+                : 'worker.workflowTask';
+        const context = {
+            kind,
+            namespace: this.#namespace,
+            taskQueue: this.#taskQueue,
+            identity: this.#identity,
+            buildId: this.#deploymentOptions.buildId,
+            workflowId: execution.workflowId,
+            runId: execution.runId,
+            attempt: Number(response.attempt ?? 1),
+            metadata: { nondeterminismRetry },
+        };
+        const effect = runWorkerInterceptors(this.#interceptors, context, () => Effect.tryPromise(() => this.#processWorkflowTask(response, nondeterminismRetry, execution)));
+        await Effect.runPromise(effect);
+    }
+    async #processWorkflowTask(response, nondeterminismRetry = 0, executionOverride) {
+        const execution = executionOverride ?? this.#resolveWorkflowExecution(response);
         const workflowTaskAttempt = Number(response.attempt ?? 1);
+        const isLegacyQueryTask = Boolean(response.query);
+        const queryStartTime = isLegacyQueryTask ? Date.now() : null;
+        if (isLegacyQueryTask) {
+            this.#incrementCounter(this.#metrics.queryTaskStarted);
+        }
         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 collectedUpdates = await collectWorkflowUpdates({
+            messages: response.messages ?? [],
+            dataConverter: this.#dataConverter,
+            log: (level, message, fields) => this.#log(level, message, fields),
+        });
         const baseLogFields = this.#workflowLogFields(execution, workflowType, {
             workflowTaskAttempt,
             stickyScheduling: this.#stickySchedulingEnabled,
             nondeterminismRetry,
         });
+        const signalDeliveries = await this.#extractSignalDeliveries(historyEvents);
+        if (signalDeliveries.length > 0) {
+            this.#log('debug', 'workflow signal deliveries buffered', {
+                ...baseLogFields,
+                signalCount: signalDeliveries.length,
+            });
+        }
+        const queryRequests = await this.#extractWorkflowQueryRequests(response);
+        const hasQueryRequests = queryRequests.length > 0;
+        const hasMultiQueries = queryRequests.some((request) => request.source === 'multi');
+        const hasLegacyQueries = queryRequests.some((request) => request.source === 'legacy');
+        if (hasQueryRequests) {
+            this.#log('debug', 'workflow queries pending evaluation', {
+                ...baseLogFields,
+                queryCount: queryRequests.length,
+            });
+        }
+        this.#log('info', 'debug: workflow task metadata', {
+            ...baseLogFields,
+            taskTokenBytes: response.taskToken?.length ?? 0,
+            queryCount: queryRequests.length,
+            historyEventCount: response.history?.events?.length ?? 0,
+        });
+        const stickyKey = this.#buildStickyKey(execution.workflowId, execution.runId);
+        const stickyEntry = stickyKey ? await this.#getStickyEntry(stickyKey) : undefined;
+        const historyReplay = await this.#ingestDeterminismState(workflowInfo, historyEvents, {
+            queryRequests,
+        });
+        const hasHistorySnapshot = this.#isValidDeterminismSnapshot(historyReplay?.determinismState);
         let previousState;
         if (stickyEntry && this.#isValidDeterminismSnapshot(stickyEntry.determinismState)) {
             const historyBaselineEventId = this.#resolvePreviousHistoryEventId(response) ?? historyReplay?.lastEventId ?? null;
@@ -574,7 +727,10 @@ export class WorkerRuntime {
         }
         const expectedDeterminismState = previousState;
         try {
-            const activityResults = await this.#extractActivityResolutions(historyEvents);
+            const { results: activityResults, scheduledEventIds: activityScheduleEventIds } = await this.#extractActivityResolutions(historyEvents);
+            const timerResults = await this.#extractTimerResolutions(historyEvents);
+            const replayUpdates = historyReplay?.updates ?? [];
+            const mergedUpdates = mergeUpdateInvocations(replayUpdates, collectedUpdates.invocations);
             const output = await this.#executor.execute({
                 workflowType,
                 workflowId: execution.workflowId,
@@ -584,10 +740,70 @@ export class WorkerRuntime {
                 arguments: args,
                 determinismState: previousState,
                 activityResults,
+                activityScheduleEventIds,
+                signalDeliveries,
+                timerResults,
+                queryRequests,
+                updates: mergedUpdates,
+                mode: isLegacyQueryTask ? 'query' : 'workflow',
+            });
+            this.#log('debug', 'workflow query evaluation summary', {
+                ...baseLogFields,
+                queryResultCount: output.queryResults.length,
             });
+            this.#log('debug', 'workflow query results raw', {
+                ...baseLogFields,
+                queryResults: output.queryResults.map((entry) => ({
+                    name: entry.request.name,
+                    source: entry.request.source,
+                    id: entry.request.id ?? null,
+                })),
+            });
+            const multiQueryResults = {};
+            let legacyQueryResult;
+            for (const entry of output.queryResults) {
+                this.#log('debug', 'workflow query evaluation completed', {
+                    ...baseLogFields,
+                    querySource: entry.request.source,
+                    queryName: entry.request.name,
+                    queryId: entry.request.id ?? null,
+                });
+                if (entry.request.source === 'multi' && entry.request.id) {
+                    multiQueryResults[entry.request.id] = entry.result;
+                }
+                else if (entry.request.source === 'legacy') {
+                    legacyQueryResult = entry;
+                }
+            }
+            if (isLegacyQueryTask) {
+                const target = legacyQueryResult ?? output.queryResults.find((entry) => entry.request.source === 'legacy');
+                if (!target) {
+                    throw new Error('Legacy query result missing from workflow execution');
+                }
+                await this.#respondLegacyQueryTask(response, target);
+                if (queryStartTime !== null) {
+                    this.#observeHistogram(this.#metrics.queryTaskLatency, Date.now() - queryStartTime);
+                }
+                this.#incrementCounter(this.#metrics.queryTaskCompleted);
+                return;
+            }
             const cacheBaselineEventId = this.#resolveCurrentStartedEventId(response) ?? historyReplay?.lastEventId ?? null;
             const shouldRecordMarker = output.completion === 'pending';
             let commandsForResponse = output.commands;
+            const dispatchesForNewMessages = (output.updateDispatches ?? []).filter((dispatch) => {
+                if (dispatch.type === 'acceptance' || dispatch.type === 'rejection') {
+                    return collectedUpdates.requestsByUpdateId.has(dispatch.updateId);
+                }
+                // Allow completion messages to be emitted even if the request metadata was seen on a prior task.
+                return true;
+            });
+            const updateProtocolMessages = await buildUpdateProtocolMessages({
+                dispatches: dispatchesForNewMessages,
+                collected: collectedUpdates,
+                dataConverter: this.#dataConverter,
+                defaultIdentity: this.#identity,
+                log: (level, message, fields) => this.#log(level, message, fields),
+            });
             if (stickyKey) {
                 if (output.completion === 'pending') {
                     await this.#upsertStickyEntry(stickyKey, output.determinismState, cacheBaselineEventId, workflowType);
@@ -598,6 +814,7 @@ export class WorkerRuntime {
                 }
                 else {
                     await this.#removeStickyEntry(stickyKey);
+                    await this.#removeStickyEntriesForWorkflow(stickyKey.workflowId);
                     this.#log('debug', 'sticky cache entry cleared (workflow completed)', baseLogFields);
                 }
             }
@@ -614,36 +831,65 @@ export class WorkerRuntime {
                 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;
+            const shouldRespondWorkflowTask = hasMultiQueries || !hasLegacyQueries;
+            if (shouldRespondWorkflowTask) {
+                const completion = create(RespondWorkflowTaskCompletedRequestSchema, {
+                    taskToken: response.taskToken,
+                    commands: commandsForResponse,
+                    identity: this.#identity,
+                    namespace: this.#namespace,
+                    deploymentOptions: this.#deploymentOptions,
+                    queryResults: multiQueryResults,
+                    ...(this.#stickySchedulingEnabled && !hasLegacyQueries ? { stickyAttributes: this.#stickyAttributes } : {}),
+                    ...(this.#versioningBehavior !== null ? { versioningBehavior: this.#versioningBehavior } : {}),
+                    ...(updateProtocolMessages.length > 0 ? { messages: updateProtocolMessages } : {}),
+                });
+                try {
+                    await this.#workflowService.respondWorkflowTaskCompleted(completion, { timeoutMs: RESPOND_TIMEOUT_MS });
+                }
+                catch (rpcError) {
+                    this.#log('error', 'debug: respondWorkflowTaskCompleted failed', {
+                        ...baseLogFields,
+                        error: rpcError instanceof Error ? rpcError.message : String(rpcError),
+                    });
+                    if (this.#isTaskNotFoundError(rpcError)) {
+                        this.#logWorkflowTaskNotFound('respondWorkflowTaskCompleted', execution);
+                        return;
+                    }
+                    throw rpcError;
                 }
-                throw rpcError;
+            }
+            if (legacyQueryResult) {
+                await this.#respondLegacyQueryTask(response, legacyQueryResult);
             }
         }
         catch (error) {
             let stickyEntryCleared = false;
             if (stickyKey) {
                 await this.#removeStickyEntry(stickyKey);
+                await this.#removeStickyEntriesForWorkflow(stickyKey.workflowId);
                 stickyEntryCleared = true;
             }
             if (this.#isTaskNotFoundError(error)) {
                 this.#logWorkflowTaskNotFound('respondWorkflowTaskCompleted', execution);
                 return;
             }
+            if (isLegacyQueryTask) {
+                this.#incrementCounter(this.#metrics.queryTaskFailed);
+                if (queryStartTime !== null) {
+                    this.#observeHistogram(this.#metrics.queryTaskLatency, Date.now() - queryStartTime);
+                }
+                if (error instanceof WorkflowNondeterminismError) {
+                    const mismatches = await this.#computeNondeterminismMismatches(error, expectedDeterminismState);
+                    this.#incrementCounter(this.#metrics.nondeterminism);
+                    this.#log('error', 'workflow query nondeterminism detected', {
+                        ...baseLogFields,
+                        mismatches,
+                    });
+                }
+                await this.#respondLegacyQueryFailure(response, error);
+                return;
+            }
             if (error instanceof WorkflowNondeterminismError) {
                 const mismatches = await this.#computeNondeterminismMismatches(error, expectedDeterminismState);
                 if (stickyKey && stickyEntryCleared) {
@@ -693,7 +939,7 @@ export class WorkerRuntime {
             runId,
         };
     }
-    async #ingestDeterminismState(workflowInfo, historyEvents) {
+    async #ingestDeterminismState(workflowInfo, historyEvents, options) {
         if (historyEvents.length === 0) {
             return undefined;
         }
@@ -701,6 +947,7 @@ export class WorkerRuntime {
             info: workflowInfo,
             history: historyEvents,
             dataConverter: this.#dataConverter,
+            queries: options?.queryRequests,
         }));
     }
     async #collectWorkflowHistory(execution, _response) {
@@ -721,6 +968,7 @@ export class WorkerRuntime {
     async #extractActivityResolutions(events) {
         const resolutions = new Map();
         const scheduledActivityIds = new Map();
+        const activityScheduleById = new Map();
         const normalizeEventId = (value) => {
             if (value === undefined || value === null) {
                 return undefined;
@@ -751,6 +999,7 @@ export class WorkerRuntime {
                     const scheduledKey = normalizeEventId(event.eventId);
                     if (activityId && scheduledKey) {
                         scheduledActivityIds.set(scheduledKey, activityId);
+                        activityScheduleById.set(activityId, scheduledKey);
                     }
                     break;
                 }
@@ -815,7 +1064,152 @@ export class WorkerRuntime {
                     break;
             }
         }
-        return resolutions;
+        return { results: resolutions, scheduledEventIds: activityScheduleById };
+    }
+    async #extractSignalDeliveries(events) {
+        const deliveries = [];
+        const normalizeEventId = (value) => {
+            if (value === undefined || value === null) {
+                return null;
+            }
+            if (typeof value === 'string') {
+                return value;
+            }
+            return value.toString();
+        };
+        for (const event of events) {
+            if (event.eventType !== EventType.WORKFLOW_EXECUTION_SIGNALED) {
+                continue;
+            }
+            if (event.attributes?.case !== 'workflowExecutionSignaledEventAttributes') {
+                continue;
+            }
+            const attrs = event.attributes.value;
+            const args = await decodePayloadsToValues(this.#dataConverter, attrs.input?.payloads ?? []);
+            const workflowTaskCompletedEventId = 'workflowTaskCompletedEventId' in attrs
+                ? normalizeEventId(attrs
+                    .workflowTaskCompletedEventId)
+                : null;
+            deliveries.push({
+                name: attrs.signalName ?? 'unknown',
+                args,
+                metadata: {
+                    eventId: normalizeEventId(event.eventId),
+                    workflowTaskCompletedEventId,
+                    identity: attrs.identity ?? null,
+                },
+            });
+        }
+        return deliveries;
+    }
+    async #extractTimerResolutions(events) {
+        const fired = new Set();
+        for (const event of events) {
+            if (event.eventType !== EventType.TIMER_FIRED) {
+                continue;
+            }
+            if (event.attributes?.case !== 'timerFiredEventAttributes') {
+                continue;
+            }
+            const attrs = event.attributes.value;
+            if (attrs.timerId) {
+                fired.add(attrs.timerId);
+            }
+        }
+        return fired;
+    }
+    async #extractWorkflowQueryRequests(response) {
+        const requests = [];
+        const map = response.queries ?? {};
+        this.#log('info', 'debug: workflow query payloads detected', {
+            namespace: this.#namespace,
+            taskQueue: this.#taskQueue,
+            workflowId: response.workflowExecution?.workflowId,
+            runId: response.workflowExecution?.runId,
+            queryMapSize: Object.keys(map).length,
+            hasLegacyQuery: Boolean(response.query),
+        });
+        for (const [id, query] of Object.entries(map)) {
+            const args = await decodePayloadsToValues(this.#dataConverter, query.queryArgs?.payloads ?? []);
+            const header = await this.#decodeQueryHeader(query);
+            requests.push({
+                id,
+                name: query.queryType ?? 'query',
+                args,
+                metadata: header ? { header } : undefined,
+                source: 'multi',
+            });
+        }
+        if (response.query) {
+            const args = await decodePayloadsToValues(this.#dataConverter, response.query.queryArgs?.payloads ?? []);
+            const header = await this.#decodeQueryHeader(response.query);
+            requests.push({
+                name: response.query.queryType ?? 'query',
+                args,
+                metadata: header ? { header } : undefined,
+                source: 'legacy',
+            });
+        }
+        return requests;
+    }
+    async #decodeQueryHeader(query) {
+        const fields = query?.header?.fields;
+        if (!fields || Object.keys(fields).length === 0) {
+            return undefined;
+        }
+        const decoded = {};
+        for (const [key, payload] of Object.entries(fields)) {
+            const values = await decodePayloadsToValues(this.#dataConverter, payload ? [payload] : []);
+            decoded[key] = values.length === 0 ? undefined : values.length === 1 ? values[0] : Object.freeze([...values]);
+        }
+        return Object.keys(decoded).length > 0 ? decoded : undefined;
+    }
+    async #respondLegacyQueryTask(response, entry) {
+        const queryResult = entry.result;
+        this.#log('debug', 'responding to legacy workflow query', {
+            namespace: this.#namespace,
+            workflowId: response.workflowExecution?.workflowId,
+            runId: response.workflowExecution?.runId,
+            queryName: entry.request.name,
+        });
+        const request = create(RespondQueryTaskCompletedRequestSchema, {
+            taskToken: response.taskToken ?? new Uint8Array(),
+            completedType: queryResult.resultType ?? QueryResultType.ANSWERED,
+            queryResult: queryResult.answer,
+            errorMessage: queryResult.errorMessage ?? '',
+            namespace: this.#namespace,
+            failure: queryResult.failure,
+            cause: WorkflowTaskFailedCause.UNSPECIFIED,
+        });
+        await this.#workflowService.respondQueryTaskCompleted(request, { timeoutMs: RESPOND_TIMEOUT_MS });
+    }
+    async #respondLegacyQueryFailure(response, cause) {
+        const failure = await encodeErrorToFailure(this.#dataConverter, cause);
+        const message = cause instanceof Error ? cause.message : 'Workflow query failed';
+        const request = create(RespondQueryTaskCompletedRequestSchema, {
+            taskToken: response.taskToken ?? new Uint8Array(),
+            completedType: QueryResultType.FAILED,
+            errorMessage: message,
+            namespace: this.#namespace,
+            failure,
+            cause: WorkflowTaskFailedCause.UNSPECIFIED,
+        });
+        try {
+            await this.#workflowService.respondQueryTaskCompleted(request, { timeoutMs: RESPOND_TIMEOUT_MS });
+        }
+        catch (rpcError) {
+            this.#log('error', 'respondQueryTaskCompleted failed for legacy query', {
+                namespace: this.#namespace,
+                workflowId: response.workflowExecution?.workflowId,
+                runId: response.workflowExecution?.runId,
+                error: rpcError instanceof Error ? rpcError.message : String(rpcError),
+            });
+            if (this.#isTaskNotFoundError(rpcError)) {
+                this.#logWorkflowTaskNotFound('respondQueryTaskCompleted', this.#resolveWorkflowExecution(response));
+                return;
+            }
+            throw rpcError;
+        }
     }
     async #fetchWorkflowHistoryPage(execution, nextPageToken) {
         if (!execution.workflowId || !execution.runId) {
@@ -931,11 +1325,13 @@ export class WorkerRuntime {
         };
     }
     async #computeNondeterminismMismatches(error, expectedState) {
-        const baseline = expectedState ?? {
-            commandHistory: [],
-            randomValues: [],
-            timeValues: [],
-            failureMetadata: undefined,
+        const baseline = {
+            commandHistory: expectedState?.commandHistory ?? [],
+            randomValues: expectedState?.randomValues ?? [],
+            timeValues: expectedState?.timeValues ?? [],
+            failureMetadata: expectedState?.failureMetadata,
+            signals: expectedState?.signals ?? [],
+            queries: expectedState?.queries ?? [],
         };
         const hint = error.details?.hint;
         if (!hint) {
@@ -944,6 +1340,8 @@ export class WorkerRuntime {
         const commandIndex = this.#parseIndexFromHint(hint, 'commandIndex');
         const randomIndex = this.#parseIndexFromHint(hint, 'randomIndex');
         const timeIndex = this.#parseIndexFromHint(hint, 'timeIndex');
+        const signalIndex = this.#parseIndexFromHint(hint, 'signalIndex');
+        const queryIndex = this.#parseIndexFromHint(hint, 'queryIndex');
         const mutableActual = {
             commandHistory: baseline.commandHistory.map((entry) => ({
                 intent: entry.intent,
@@ -952,6 +1350,8 @@ export class WorkerRuntime {
             randomValues: [...baseline.randomValues],
             timeValues: [...baseline.timeValues],
             failureMetadata: baseline.failureMetadata ? { ...baseline.failureMetadata } : undefined,
+            signals: baseline.signals.map((record) => ({ ...record })),
+            queries: baseline.queries.map((record) => ({ ...record })),
         };
         let mutated = false;
         if (commandIndex !== null) {
@@ -980,6 +1380,36 @@ export class WorkerRuntime {
             mutableActual.timeValues[timeIndex] = Number.NaN;
             mutated = true;
         }
+        if (signalIndex !== null) {
+            const receivedSignal = this.#asSignalRecord(error.details?.received);
+            if (receivedSignal) {
+                if (signalIndex < mutableActual.signals.length) {
+                    mutableActual.signals = mutableActual.signals.map((record, idx) => idx === signalIndex ? receivedSignal : record);
+                }
+                else {
+                    mutableActual.signals = [...mutableActual.signals, receivedSignal];
+                }
+            }
+            else if (signalIndex < mutableActual.signals.length) {
+                mutableActual.signals = mutableActual.signals.filter((_, idx) => idx !== signalIndex);
+            }
+            mutated = true;
+        }
+        if (queryIndex !== null) {
+            const receivedQuery = this.#asQueryRecord(error.details?.received);
+            if (receivedQuery) {
+                if (queryIndex < mutableActual.queries.length) {
+                    mutableActual.queries = mutableActual.queries.map((record, idx) => idx === queryIndex ? receivedQuery : record);
+                }
+                else {
+                    mutableActual.queries = [...mutableActual.queries, receivedQuery];
+                }
+            }
+            else if (queryIndex < mutableActual.queries.length) {
+                mutableActual.queries = mutableActual.queries.filter((_, idx) => idx !== queryIndex);
+            }
+            mutated = true;
+        }
         if (!mutated) {
             return [];
         }
@@ -988,6 +1418,8 @@ export class WorkerRuntime {
             randomValues: mutableActual.randomValues,
             timeValues: mutableActual.timeValues,
             failureMetadata: mutableActual.failureMetadata,
+            signals: mutableActual.signals,
+            queries: mutableActual.queries,
         };
         const diff = await Effect.runPromise(diffDeterminismState(baseline, actualState));
         return diff.mismatches;
@@ -1030,6 +1462,24 @@ export class WorkerRuntime {
             array.push(Number.NaN);
         }
     }
+    #asSignalRecord(value) {
+        if (!value || typeof value !== 'object') {
+            return undefined;
+        }
+        if ('signalName' in value && 'payloadHash' in value) {
+            return value;
+        }
+        return undefined;
+    }
+    #asQueryRecord(value) {
+        if (!value || typeof value !== 'object') {
+            return undefined;
+        }
+        if ('queryName' in value && 'requestHash' in value) {
+            return value;
+        }
+        return undefined;
+    }
     static #isStickyCacheInstance(value) {
         if (!value || typeof value !== 'object') {
             return false;
@@ -1042,6 +1492,11 @@ export class WorkerRuntime {
     async #removeStickyEntry(key) {
         await Effect.runPromise(this.#stickyCache.remove(key));
     }
+    async #removeStickyEntriesForWorkflow(workflowId) {
+        if (!workflowId)
+            return;
+        await Effect.runPromise(this.#stickyCache.removeByWorkflow({ namespace: this.#namespace, workflowId }));
+    }
     async #failWorkflowTask(response, execution, error, cause = WorkflowTaskFailedCause.UNSPECIFIED) {
         const failure = await encodeErrorToFailure(this.#dataConverter, error);
         const encoded = await encodeFailurePayloads(this.#dataConverter, failure);
@@ -1065,6 +1520,20 @@ export class WorkerRuntime {
             throw rpcError;
         }
     }
+    async #runActivityTask(response) {
+        const context = {
+            kind: 'worker.activityTask',
+            namespace: this.#namespace,
+            taskQueue: this.#taskQueue,
+            identity: this.#identity,
+            buildId: this.#deploymentOptions.buildId,
+            workflowId: response.workflowExecution?.workflowId ?? undefined,
+            runId: response.workflowExecution?.runId ?? undefined,
+            attempt: Number(response.attempt ?? 1),
+        };
+        const effect = runWorkerInterceptors(this.#interceptors, context, () => Effect.tryPromise(() => this.#processActivityTask(response)));
+        await Effect.runPromise(effect);
+    }
     async #processActivityTask(response) {
         const cancelRequested = isActivityCancelRequested(response);
         if (cancelRequested) {