@proompteng/temporal-bun-sdk 0.3.0 → 0.5.0

package/dist/src/workflow/replay.js

@@ -2,12 +2,13 @@ import { create } from '@bufbuild/protobuf';
 import { Effect } from 'effect';
 import { durationToMillis } from '../common/duration';
 import { decodePayloadsToValues, encodeValuesToPayloads } from '../common/payloads';
-import { PayloadsSchema } from '../proto/temporal/api/common/v1/message_pb';
+import { PayloadsSchema, } from '../proto/temporal/api/common/v1/message_pb';
 import { EventType } from '../proto/temporal/api/enums/v1/event_type_pb';
 import { ParentClosePolicy, TimeoutType, WorkflowIdReusePolicy } from '../proto/temporal/api/enums/v1/workflow_pb';
 import { intentsEqual, stableStringify } from './determinism';
 export const DETERMINISM_MARKER_NAME = 'temporal-bun-sdk/determinism';
-const DETERMINISM_MARKER_SCHEMA_VERSION = 1;
+const DETERMINISM_MARKER_SCHEMA_VERSION_V1 = 1;
+const DETERMINISM_MARKER_SCHEMA_VERSION_V2 = 2;
 const DETERMINISM_MARKER_DETAIL_KEY = 'snapshot';
 /**
  * Encode a workflow determinism snapshot into a marker payload map suitable for
@@ -15,13 +16,25 @@ const DETERMINISM_MARKER_DETAIL_KEY = 'snapshot';
  */
 export const encodeDeterminismMarkerDetails = (converter, input) => Effect.tryPromise(async () => {
     const recordedAt = (input.recordedAt ?? new Date()).toISOString();
-    const envelope = {
-        schemaVersion: DETERMINISM_MARKER_SCHEMA_VERSION,
-        workflow: input.info,
-        determinismState: input.determinismState,
-        lastEventId: normalizeEventId(input.lastEventId),
-        recordedAtIso: recordedAt,
-    };
+    const markerType = input.markerType ?? 'full';
+    if (markerType === 'delta' && !input.determinismDelta) {
+        throw new Error('Determinism marker delta payload missing');
+    }
+    const envelope = markerType === 'delta'
+        ? {
+            schemaVersion: DETERMINISM_MARKER_SCHEMA_VERSION_V2,
+            workflow: input.info,
+            determinismDelta: input.determinismDelta,
+            lastEventId: normalizeEventId(input.lastEventId),
+            recordedAtIso: recordedAt,
+        }
+        : {
+            schemaVersion: DETERMINISM_MARKER_SCHEMA_VERSION_V1,
+            workflow: input.info,
+            determinismState: input.determinismState,
+            lastEventId: normalizeEventId(input.lastEventId),
+            recordedAtIso: recordedAt,
+        };
     const payloads = await encodeValuesToPayloads(converter, [envelope]);
     if (!payloads || payloads.length === 0) {
         throw new Error('Failed to encode determinism marker payloads');
@@ -30,6 +43,20 @@ export const encodeDeterminismMarkerDetails = (converter, input) => Effect.tryPr
         [DETERMINISM_MARKER_DETAIL_KEY]: create(PayloadsSchema, { payloads }),
     };
 });
+export const measurePayloadsByteSize = (details) => {
+    let total = 0;
+    for (const payloads of Object.values(details)) {
+        for (const payload of payloads.payloads ?? []) {
+            total += payload.data?.byteLength ?? 0;
+            const metadata = payload.metadata ?? {};
+            for (const value of Object.values(metadata)) {
+                total += value?.byteLength ?? 0;
+            }
+        }
+    }
+    return total;
+};
+export const encodeDeterminismMarkerDetailsWithSize = (converter, input) => encodeDeterminismMarkerDetails(converter, input).pipe(Effect.map((details) => ({ details, sizeBytes: measurePayloadsByteSize(details) })));
 /**
  * Decode determinism snapshot metadata from a marker payload map. Returns
  * `undefined` when the supplied details do not contain a determinism snapshot.
@@ -57,10 +84,14 @@ export const decodeDeterminismMarkerEnvelope = (input) => Effect.tryPromise(asyn
 export const ingestWorkflowHistory = (intake) => Effect.gen(function* () {
     const events = sortHistoryEvents(intake.history ?? []);
     const shouldUseDeterminismMarker = intake.ignoreDeterminismMarker !== true;
-    let markerSnapshot;
-    const updateEntries = collectWorkflowUpdateEntries(events);
+    let markerState;
+    let markerLastEventId = null;
+    let markerEventId = null;
+    let markerEventIndex = null;
+    let markerInvalid = false;
+    let hasMarker = false;
     if (shouldUseDeterminismMarker) {
-        for (const event of events) {
+        for (const [index, event] of events.entries()) {
             if (event.eventType !== EventType.MARKER_RECORDED) {
                 continue;
             }
@@ -72,36 +103,82 @@ export const ingestWorkflowHistory = (intake) => Effect.gen(function* () {
                 details: event.attributes.value.details,
             }), () => Effect.succeed(undefined));
             if (decoded) {
-                markerSnapshot = decoded;
+                const applied = applyDeterminismMarker(markerState, decoded);
+                if (!applied) {
+                    markerInvalid = true;
+                    break;
+                }
+                markerState = applied;
+                markerLastEventId = decoded.lastEventId;
+                markerEventId = normalizeEventId(event.eventId);
+                markerEventIndex = index;
+                hasMarker = true;
             }
         }
     }
     const extractedFailureMetadata = extractFailureMetadata(events);
-    const replayUpdateInvocations = yield* Effect.tryPromise(async () => collectWorkflowUpdateInvocations(events, intake.dataConverter));
-    if (shouldUseDeterminismMarker && markerSnapshot) {
-        let determinismState = cloneDeterminismState(markerSnapshot.determinismState);
-        if (!determinismState.failureMetadata && extractedFailureMetadata) {
-            determinismState = {
-                ...determinismState,
-                failureMetadata: extractedFailureMetadata,
-            };
+    const historyLastEventId = resolveHistoryLastEventId(events) ?? null;
+    if (shouldUseDeterminismMarker && hasMarker && !markerInvalid && markerState && markerEventIndex !== null) {
+        const historyKinds = collectCommandKinds(events.slice(0, markerEventIndex + 1));
+        const markerKinds = markerState.commandHistory.map((entry) => entry.intent.kind);
+        if (!commandKindsMatch(markerKinds, historyKinds)) {
+            markerInvalid = true;
+            markerState = undefined;
         }
-        if ((!determinismState.updates || determinismState.updates.length === 0) && updateEntries.length > 0) {
-            determinismState = {
-                ...determinismState,
-                updates: updateEntries,
+    }
+    const eventsAfterMarker = shouldUseDeterminismMarker && hasMarker && markerEventIndex !== null ? events.slice(markerEventIndex + 1) : events;
+    const replayUpdateInvocationsAfterMarker = yield* Effect.tryPromise(async () => collectWorkflowUpdateInvocations(eventsAfterMarker, intake.dataConverter));
+    const updateEntriesAfterMarker = collectWorkflowUpdateEntries(eventsAfterMarker);
+    const replayUpdateInvocationsFull = yield* Effect.tryPromise(async () => collectWorkflowUpdateInvocations(events, intake.dataConverter));
+    const updateEntriesFull = collectWorkflowUpdateEntries(events);
+    const markerCoversHistory = markerEventId !== null && markerEventId === historyLastEventId;
+    const historyCommandCount = countHistoryCommandEvents(events);
+    if (shouldUseDeterminismMarker && hasMarker && !markerInvalid && markerState) {
+        if (markerCoversHistory || eventsAfterMarker.length === 0) {
+            let determinismState = cloneDeterminismState(markerState);
+            if (!determinismState.failureMetadata && extractedFailureMetadata) {
+                determinismState = {
+                    ...determinismState,
+                    failureMetadata: extractedFailureMetadata,
+                };
+            }
+            if ((!determinismState.updates || determinismState.updates.length === 0) &&
+                updateEntriesAfterMarker.length > 0) {
+                determinismState = {
+                    ...determinismState,
+                    updates: updateEntriesAfterMarker,
+                };
+            }
+            determinismState = mergePendingQueryRequests(determinismState, intake.queries);
+            const latestEventId = historyLastEventId ?? markerLastEventId ?? null;
+            if (determinismState.commandHistory.length !== historyCommandCount) {
+                return yield* reconstructDeterminismState(events, intake, extractedFailureMetadata, updateEntriesFull, replayUpdateInvocationsFull);
+            }
+            return {
+                determinismState,
+                lastEventId: latestEventId,
+                hasDeterminismMarker: true,
+                markerState: cloneDeterminismState(markerState),
+                ...(replayUpdateInvocationsFull.length > 0 ? { updates: replayUpdateInvocationsFull } : {}),
             };
         }
-        determinismState = mergePendingQueryRequests(determinismState, intake.queries);
-        const latestEventId = resolveHistoryLastEventId(events) ?? markerSnapshot.lastEventId ?? null;
+        const replayed = yield* reconstructDeterminismState(eventsAfterMarker, intake, extractedFailureMetadata, updateEntriesAfterMarker, replayUpdateInvocationsAfterMarker, {
+            seedState: markerState,
+            historyLastEventId,
+            seedHistoryEvents: markerEventIndex !== null ? events.slice(0, markerEventIndex + 1) : undefined,
+        });
+        if (replayed.determinismState.commandHistory.length !== historyCommandCount) {
+            return yield* reconstructDeterminismState(events, intake, extractedFailureMetadata, updateEntriesFull, replayUpdateInvocationsFull);
+        }
         return {
-            determinismState,
-            lastEventId: latestEventId,
+            ...replayed,
             hasDeterminismMarker: true,
-            ...(replayUpdateInvocations.length > 0 ? { updates: replayUpdateInvocations } : {}),
+            markerState: cloneDeterminismState(markerState),
+            lastEventId: historyLastEventId ?? markerLastEventId ?? null,
+            ...(replayUpdateInvocationsFull.length > 0 ? { updates: replayUpdateInvocationsFull } : {}),
         };
     }
-    return yield* reconstructDeterminismState(events, intake, extractedFailureMetadata, updateEntries, replayUpdateInvocations);
+    return yield* reconstructDeterminismState(events, intake, extractedFailureMetadata, updateEntriesFull, replayUpdateInvocationsFull);
 });
 /**
  * Diff determinism state against freshly emitted intents to produce rich
@@ -220,6 +297,7 @@ export const cloneDeterminismState = (state) => ({
     })),
     randomValues: [...state.randomValues],
     timeValues: [...state.timeValues],
+    ...(state.logCount !== undefined ? { logCount: state.logCount } : {}),
     failureMetadata: state.failureMetadata ? { ...state.failureMetadata } : undefined,
     signals: state.signals ? state.signals.map((record) => ({ ...record })) : [],
     queries: state.queries ? state.queries.map((record) => ({ ...record })) : [],
@@ -384,12 +462,295 @@ const resolveCommandMismatchMetadata = (expectedEntry, actualEntry) => {
         eventType,
     };
 };
-const reconstructDeterminismState = (events, intake, failureMetadata, precomputedUpdates, replayUpdateInvocations = []) => Effect.gen(function* () {
-    let sequence = 0;
-    const commandHistory = [];
-    const signalRecords = [];
-    const queryRecords = [];
-    const updates = precomputedUpdates ?? collectWorkflowUpdateEntries(events);
+const seedDeterminismEventMaps = (state, seedEvents) => {
+    const scheduledActivities = new Map();
+    const timersByStartEventId = new Map();
+    if (!state) {
+        if (seedEvents) {
+            seedDeterminismEventMapsFromHistory(scheduledActivities, timersByStartEventId, seedEvents);
+        }
+        return { scheduledActivities, timersByStartEventId };
+    }
+    for (const entry of state.commandHistory) {
+        const eventId = entry.metadata?.eventId;
+        if (!eventId) {
+            continue;
+        }
+        if (entry.intent.kind === 'schedule-activity') {
+            scheduledActivities.set(eventId, entry.intent.activityId);
+            continue;
+        }
+        if (entry.intent.kind === 'start-timer') {
+            timersByStartEventId.set(eventId, entry.intent.timerId);
+        }
+    }
+    if (seedEvents) {
+        seedDeterminismEventMapsFromHistory(scheduledActivities, timersByStartEventId, seedEvents);
+    }
+    return { scheduledActivities, timersByStartEventId };
+};
+const seedDeterminismEventMapsFromHistory = (scheduledActivities, timersByStartEventId, events) => {
+    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 eventId = normalizeEventId(event.eventId);
+                if (activityId && eventId && !scheduledActivities.has(eventId)) {
+                    scheduledActivities.set(eventId, activityId);
+                }
+                break;
+            }
+            case EventType.TIMER_STARTED: {
+                if (event.attributes?.case !== 'timerStartedEventAttributes') {
+                    break;
+                }
+                const timerId = event.attributes.value.timerId;
+                const eventId = normalizeEventId(event.eventId);
+                if (timerId && eventId && !timersByStartEventId.has(eventId)) {
+                    timersByStartEventId.set(eventId, timerId);
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+};
+const countHistoryCommandEvents = (events) => {
+    const { scheduledActivities, timersByStartEventId } = seedDeterminismEventMaps(undefined, events);
+    let count = 0;
+    for (const event of events) {
+        switch (event.eventType) {
+            case EventType.ACTIVITY_TASK_SCHEDULED: {
+                if (event.attributes?.case !== 'activityTaskScheduledEventAttributes') {
+                    break;
+                }
+                if (event.attributes.value.activityType?.name) {
+                    count += 1;
+                }
+                break;
+            }
+            case EventType.TIMER_STARTED: {
+                if (event.attributes?.case !== 'timerStartedEventAttributes') {
+                    break;
+                }
+                if (durationToMillis(event.attributes.value.startToFireTimeout) !== undefined) {
+                    count += 1;
+                }
+                break;
+            }
+            case EventType.START_CHILD_WORKFLOW_EXECUTION_INITIATED: {
+                if (event.attributes?.case !== 'startChildWorkflowExecutionInitiatedEventAttributes') {
+                    break;
+                }
+                if (event.attributes.value.workflowType?.name) {
+                    count += 1;
+                }
+                break;
+            }
+            case EventType.ACTIVITY_TASK_CANCEL_REQUESTED: {
+                if (event.attributes?.case !== 'activityTaskCancelRequestedEventAttributes') {
+                    break;
+                }
+                const scheduledEventId = normalizeBigintIdentifier(event.attributes.value.scheduledEventId);
+                if (scheduledEventId && scheduledActivities.has(scheduledEventId)) {
+                    count += 1;
+                }
+                break;
+            }
+            case EventType.TIMER_CANCELED: {
+                if (event.attributes?.case !== 'timerCanceledEventAttributes') {
+                    break;
+                }
+                const startedEventId = normalizeBigintIdentifier(event.attributes.value.startedEventId);
+                if (startedEventId && timersByStartEventId.has(startedEventId)) {
+                    count += 1;
+                }
+                break;
+            }
+            case EventType.SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_INITIATED: {
+                if (event.attributes?.case !== 'signalExternalWorkflowExecutionInitiatedEventAttributes') {
+                    break;
+                }
+                if (event.attributes.value.signalName) {
+                    count += 1;
+                }
+                break;
+            }
+            case EventType.REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_INITIATED: {
+                if (event.attributes?.case !== 'requestCancelExternalWorkflowExecutionInitiatedEventAttributes') {
+                    break;
+                }
+                count += 1;
+                break;
+            }
+            case EventType.WORKFLOW_EXECUTION_CONTINUED_AS_NEW: {
+                if (event.attributes?.case !== 'workflowExecutionContinuedAsNewEventAttributes') {
+                    break;
+                }
+                count += 1;
+                break;
+            }
+            case EventType.MARKER_RECORDED: {
+                if (event.attributes?.case !== 'markerRecordedEventAttributes') {
+                    break;
+                }
+                if (event.attributes.value.markerName !== DETERMINISM_MARKER_NAME) {
+                    count += 1;
+                }
+                break;
+            }
+            case EventType.UPSERT_WORKFLOW_SEARCH_ATTRIBUTES: {
+                if (event.attributes?.case !== 'upsertWorkflowSearchAttributesEventAttributes') {
+                    break;
+                }
+                count += 1;
+                break;
+            }
+            case EventType.WORKFLOW_PROPERTIES_MODIFIED: {
+                if (event.attributes?.case !== 'workflowPropertiesModifiedEventAttributes') {
+                    break;
+                }
+                count += 1;
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return count;
+};
+const commandKindsMatch = (expected, actual) => {
+    if (expected.length !== actual.length) {
+        return false;
+    }
+    for (let index = 0; index < expected.length; index += 1) {
+        if (expected[index] !== actual[index]) {
+            return false;
+        }
+    }
+    return true;
+};
+const collectCommandKinds = (events) => {
+    const { scheduledActivities, timersByStartEventId } = seedDeterminismEventMaps(undefined, events);
+    const kinds = [];
+    for (const event of events) {
+        switch (event.eventType) {
+            case EventType.ACTIVITY_TASK_SCHEDULED: {
+                if (event.attributes?.case !== 'activityTaskScheduledEventAttributes') {
+                    break;
+                }
+                if (event.attributes.value.activityType?.name) {
+                    kinds.push('schedule-activity');
+                }
+                break;
+            }
+            case EventType.TIMER_STARTED: {
+                if (event.attributes?.case !== 'timerStartedEventAttributes') {
+                    break;
+                }
+                if (event.attributes.value.timerId) {
+                    kinds.push('start-timer');
+                }
+                break;
+            }
+            case EventType.START_CHILD_WORKFLOW_EXECUTION_INITIATED: {
+                if (event.attributes?.case !== 'startChildWorkflowExecutionInitiatedEventAttributes') {
+                    break;
+                }
+                if (event.attributes.value.workflowType?.name) {
+                    kinds.push('start-child-workflow');
+                }
+                break;
+            }
+            case EventType.ACTIVITY_TASK_CANCEL_REQUESTED: {
+                if (event.attributes?.case !== 'activityTaskCancelRequestedEventAttributes') {
+                    break;
+                }
+                const scheduledKey = normalizeEventId(event.attributes.value.scheduledEventId);
+                if (scheduledKey && scheduledActivities.has(scheduledKey)) {
+                    kinds.push('request-cancel-activity');
+                }
+                break;
+            }
+            case EventType.TIMER_CANCELED: {
+                if (event.attributes?.case !== 'timerCanceledEventAttributes') {
+                    break;
+                }
+                const startedKey = normalizeEventId(event.attributes.value.startedEventId);
+                if (startedKey && timersByStartEventId.has(startedKey)) {
+                    kinds.push('cancel-timer');
+                }
+                break;
+            }
+            case EventType.SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_INITIATED: {
+                if (event.attributes?.case !== 'signalExternalWorkflowExecutionInitiatedEventAttributes') {
+                    break;
+                }
+                if (event.attributes.value.signalName) {
+                    kinds.push('signal-external-workflow');
+                }
+                break;
+            }
+            case EventType.REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_INITIATED: {
+                if (event.attributes?.case !== 'requestCancelExternalWorkflowExecutionInitiatedEventAttributes') {
+                    break;
+                }
+                if (event.attributes.value.workflowExecution?.workflowId) {
+                    kinds.push('request-cancel-external-workflow');
+                }
+                break;
+            }
+            case EventType.WORKFLOW_EXECUTION_CONTINUED_AS_NEW: {
+                if (event.attributes?.case !== 'workflowExecutionContinuedAsNewEventAttributes') {
+                    break;
+                }
+                kinds.push('continue-as-new');
+                break;
+            }
+            case EventType.MARKER_RECORDED: {
+                if (event.attributes?.case !== 'markerRecordedEventAttributes') {
+                    break;
+                }
+                if (event.attributes.value.markerName !== DETERMINISM_MARKER_NAME) {
+                    kinds.push('record-marker');
+                }
+                break;
+            }
+            case EventType.UPSERT_WORKFLOW_SEARCH_ATTRIBUTES: {
+                if (event.attributes?.case !== 'upsertWorkflowSearchAttributesEventAttributes') {
+                    break;
+                }
+                kinds.push('upsert-search-attributes');
+                break;
+            }
+            case EventType.WORKFLOW_PROPERTIES_MODIFIED: {
+                if (event.attributes?.case !== 'workflowPropertiesModifiedEventAttributes') {
+                    break;
+                }
+                kinds.push('modify-workflow-properties');
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return kinds;
+};
+const reconstructDeterminismState = (events, intake, failureMetadata, precomputedUpdates, replayUpdateInvocations = [], options) => Effect.gen(function* () {
+    const seededState = options?.seedState ? cloneDeterminismState(options.seedState) : undefined;
+    let sequence = seededState?.commandHistory.length ?? 0;
+    const commandHistory = seededState ? [...seededState.commandHistory] : [];
+    const signalRecords = seededState ? [...seededState.signals] : [];
+    const queryRecords = seededState ? [...seededState.queries] : [];
+    const updateEntries = precomputedUpdates ?? collectWorkflowUpdateEntries(events);
+    const updates = seededState?.updates && seededState.updates.length > 0
+        ? [...seededState.updates, ...updateEntries]
+        : updateEntries;
+    const { scheduledActivities, timersByStartEventId } = seedDeterminismEventMaps(seededState, options?.seedHistoryEvents);
     for (const event of events) {
         switch (event.eventType) {
             case EventType.ACTIVITY_TASK_SCHEDULED: {
@@ -402,6 +763,10 @@ const reconstructDeterminismState = (events, intake, failureMetadata, precompute
                         intent,
                         metadata: buildCommandMetadata(event, event.attributes.value),
                     });
+                    const scheduledKey = normalizeEventId(event.eventId);
+                    if (scheduledKey) {
+                        scheduledActivities.set(scheduledKey, intent.activityId);
+                    }
                     sequence += 1;
                 }
                 break;
@@ -416,6 +781,10 @@ const reconstructDeterminismState = (events, intake, failureMetadata, precompute
                         intent,
                         metadata: buildCommandMetadata(event, event.attributes.value),
                     });
+                    const startKey = normalizeEventId(event.eventId);
+                    if (startKey) {
+                        timersByStartEventId.set(startKey, intent.timerId);
+                    }
                     sequence += 1;
                 }
                 break;
@@ -434,6 +803,34 @@ const reconstructDeterminismState = (events, intake, failureMetadata, precompute
                 }
                 break;
             }
+            case EventType.ACTIVITY_TASK_CANCEL_REQUESTED: {
+                if (event.attributes?.case !== 'activityTaskCancelRequestedEventAttributes') {
+                    break;
+                }
+                const intent = fromActivityTaskCancelRequested(event.attributes.value, sequence, scheduledActivities);
+                if (intent) {
+                    commandHistory.push({
+                        intent,
+                        metadata: buildCommandMetadata(event, event.attributes.value),
+                    });
+                    sequence += 1;
+                }
+                break;
+            }
+            case EventType.TIMER_CANCELED: {
+                if (event.attributes?.case !== 'timerCanceledEventAttributes') {
+                    break;
+                }
+                const intent = fromTimerCanceled(event.attributes.value, sequence, timersByStartEventId);
+                if (intent) {
+                    commandHistory.push({
+                        intent,
+                        metadata: buildCommandMetadata(event, event.attributes.value),
+                    });
+                    sequence += 1;
+                }
+                break;
+            }
             case EventType.SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_INITIATED: {
                 if (event.attributes?.case !== 'signalExternalWorkflowExecutionInitiatedEventAttributes') {
                     break;
@@ -448,6 +845,20 @@ const reconstructDeterminismState = (events, intake, failureMetadata, precompute
                 }
                 break;
             }
+            case EventType.REQUEST_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_INITIATED: {
+                if (event.attributes?.case !== 'requestCancelExternalWorkflowExecutionInitiatedEventAttributes') {
+                    break;
+                }
+                const intent = fromRequestCancelExternalWorkflow(event.attributes.value, sequence, intake);
+                if (intent) {
+                    commandHistory.push({
+                        intent,
+                        metadata: buildCommandMetadata(event, event.attributes.value),
+                    });
+                    sequence += 1;
+                }
+                break;
+            }
             case EventType.WORKFLOW_EXECUTION_SIGNALED: {
                 if (event.attributes?.case !== 'workflowExecutionSignaledEventAttributes') {
                     break;
@@ -481,15 +892,61 @@ const reconstructDeterminismState = (events, intake, failureMetadata, precompute
                 }
                 break;
             }
+            case EventType.MARKER_RECORDED: {
+                if (event.attributes?.case !== 'markerRecordedEventAttributes') {
+                    break;
+                }
+                if (event.attributes.value.markerName === DETERMINISM_MARKER_NAME) {
+                    break;
+                }
+                const intent = yield* fromMarkerRecorded(event.attributes.value, sequence, intake);
+                if (intent) {
+                    commandHistory.push({
+                        intent,
+                        metadata: buildCommandMetadata(event, event.attributes.value),
+                    });
+                    sequence += 1;
+                }
+                break;
+            }
+            case EventType.UPSERT_WORKFLOW_SEARCH_ATTRIBUTES: {
+                if (event.attributes?.case !== 'upsertWorkflowSearchAttributesEventAttributes') {
+                    break;
+                }
+                const intent = yield* fromUpsertSearchAttributes(event.attributes.value, sequence, intake);
+                if (intent) {
+                    commandHistory.push({
+                        intent,
+                        metadata: buildCommandMetadata(event, event.attributes.value),
+                    });
+                    sequence += 1;
+                }
+                break;
+            }
+            case EventType.WORKFLOW_PROPERTIES_MODIFIED: {
+                if (event.attributes?.case !== 'workflowPropertiesModifiedEventAttributes') {
+                    break;
+                }
+                const intent = yield* fromWorkflowPropertiesModified(event.attributes.value, sequence, intake);
+                if (intent) {
+                    commandHistory.push({
+                        intent,
+                        metadata: buildCommandMetadata(event, event.attributes.value),
+                    });
+                    sequence += 1;
+                }
+                break;
+            }
             default:
                 break;
         }
     }
+    const resolvedFailureMetadata = failureMetadata ?? seededState?.failureMetadata;
     let determinismState = {
         commandHistory,
-        randomValues: [],
-        timeValues: [],
-        ...(failureMetadata ? { failureMetadata } : {}),
+        randomValues: seededState?.randomValues ?? [],
+        timeValues: seededState?.timeValues ?? [],
+        ...(resolvedFailureMetadata ? { failureMetadata: resolvedFailureMetadata } : {}),
         signals: signalRecords,
         queries: queryRecords,
         ...(updates.length > 0 ? { updates } : {}),
@@ -497,7 +954,7 @@ const reconstructDeterminismState = (events, intake, failureMetadata, precompute
     determinismState = mergePendingQueryRequests(determinismState, intake.queries);
     return {
         determinismState,
-        lastEventId: resolveHistoryLastEventId(events),
+        lastEventId: options?.historyLastEventId ?? resolveHistoryLastEventId(events),
         hasDeterminismMarker: false,
         ...(replayUpdateInvocations.length > 0 ? { updates: replayUpdateInvocations } : {}),
     };
@@ -622,6 +1079,85 @@ const fromContinueAsNew = (attributes, sequence, intake) => Effect.gen(function*
     };
     return intent;
 });
+const fromActivityTaskCancelRequested = (attributes, sequence, scheduledActivities) => {
+    const scheduledEventId = normalizeBigintIdentifier(attributes.scheduledEventId);
+    if (!scheduledEventId) {
+        return undefined;
+    }
+    const activityId = scheduledActivities.get(scheduledEventId);
+    if (!activityId) {
+        return undefined;
+    }
+    return {
+        id: `cancel-activity-${sequence}`,
+        kind: 'request-cancel-activity',
+        sequence,
+        activityId,
+        scheduledEventId,
+    };
+};
+const fromTimerCanceled = (attributes, sequence, timersByStartEventId) => {
+    const startedEventId = normalizeBigintIdentifier(attributes.startedEventId);
+    const timerId = attributes.timerId || (startedEventId ? timersByStartEventId.get(startedEventId) : undefined);
+    if (!timerId) {
+        return undefined;
+    }
+    return {
+        id: `cancel-timer-${sequence}`,
+        kind: 'cancel-timer',
+        sequence,
+        timerId,
+        startedEventId,
+    };
+};
+const fromRequestCancelExternalWorkflow = (attributes, sequence, intake) => {
+    const workflowId = attributes.workflowExecution?.workflowId ?? intake.info.workflowId;
+    if (!workflowId) {
+        return undefined;
+    }
+    return {
+        id: `cancel-external-${sequence}`,
+        kind: 'request-cancel-external-workflow',
+        sequence,
+        namespace: attributes.namespace || intake.info.namespace,
+        workflowId,
+        runId: attributes.workflowExecution?.runId || undefined,
+        childWorkflowOnly: attributes.childWorkflowOnly ?? false,
+        reason: attributes.reason || undefined,
+    };
+};
+const fromMarkerRecorded = (attributes, sequence, intake) => Effect.gen(function* () {
+    const markerName = attributes.markerName || 'marker';
+    const details = yield* decodeMarkerDetails(intake.dataConverter, attributes.details);
+    return {
+        id: `record-marker-${sequence}`,
+        kind: 'record-marker',
+        sequence,
+        markerName,
+        details,
+    };
+});
+const fromUpsertSearchAttributes = (attributes, sequence, intake) => Effect.gen(function* () {
+    const searchAttributes = yield* decodeSearchAttributes(intake.dataConverter, attributes.searchAttributes);
+    if (!searchAttributes) {
+        return undefined;
+    }
+    return {
+        id: `upsert-search-attributes-${sequence}`,
+        kind: 'upsert-search-attributes',
+        sequence,
+        searchAttributes,
+    };
+});
+const fromWorkflowPropertiesModified = (attributes, sequence, intake) => Effect.gen(function* () {
+    const memo = yield* decodeMemo(intake.dataConverter, attributes.upsertedMemo);
+    return {
+        id: `modify-workflow-properties-${sequence}`,
+        kind: 'modify-workflow-properties',
+        sequence,
+        memo,
+    };
+});
 const collectWorkflowUpdateEntries = (events) => {
     const updates = [];
     for (const event of events) {
@@ -715,7 +1251,19 @@ const collectWorkflowUpdateEntries = (events) => {
     return updates;
 };
 const collectWorkflowUpdateInvocations = async (events, dataConverter) => {
-    const invocations = [];
+    const candidates = [];
+    let order = 0;
+    const parseSequencing = (value) => {
+        if (!value) {
+            return undefined;
+        }
+        try {
+            return BigInt(value);
+        }
+        catch {
+            return undefined;
+        }
+    };
     for (const event of events) {
         if (event.eventType === EventType.WORKFLOW_EXECUTION_UPDATE_ACCEPTED) {
             if (event.attributes.case !== 'workflowExecutionUpdateAcceptedEventAttributes') {
@@ -731,25 +1279,8 @@ const collectWorkflowUpdateInvocations = async (events, dataConverter) => {
                 dataConverter,
             });
             if (invocation) {
-                invocations.push(invocation);
-            }
-            continue;
-        }
-        if (event.eventType === EventType.WORKFLOW_EXECUTION_UPDATE_REJECTED) {
-            if (event.attributes.case !== 'workflowExecutionUpdateRejectedEventAttributes') {
-                continue;
-            }
-            const attrs = event.attributes.value;
-            const invocation = await buildUpdateInvocationFromRequest({
-                request: attrs.rejectedRequest,
-                protocolInstanceId: attrs.protocolInstanceId,
-                requestMessageId: attrs.rejectedRequestMessageId,
-                sequencingEventId: attrs.rejectedRequestSequencingEventId,
-                fallbackEventId: event.eventId,
-                dataConverter,
-            });
-            if (invocation) {
-                invocations.push(invocation);
+                candidates.push({ invocation, sequencing: parseSequencing(invocation.sequencingEventId), order });
+                order += 1;
             }
             continue;
         }
@@ -767,11 +1298,59 @@ const collectWorkflowUpdateInvocations = async (events, dataConverter) => {
                 dataConverter,
             });
             if (invocation) {
-                invocations.push(invocation);
+                candidates.push({ invocation, sequencing: parseSequencing(invocation.sequencingEventId), order });
+                order += 1;
             }
         }
     }
-    return invocations;
+    const byUpdateId = new Map();
+    for (const candidate of candidates) {
+        const updateId = candidate.invocation.updateId;
+        const existing = byUpdateId.get(updateId);
+        if (!existing) {
+            byUpdateId.set(updateId, candidate);
+            continue;
+        }
+        const existingSeq = existing.sequencing;
+        const candidateSeq = candidate.sequencing;
+        if (candidateSeq !== undefined && existingSeq !== undefined) {
+            if (candidateSeq < existingSeq) {
+                byUpdateId.set(updateId, candidate);
+            }
+            continue;
+        }
+        if (candidateSeq !== undefined && existingSeq === undefined) {
+            byUpdateId.set(updateId, candidate);
+            continue;
+        }
+        if (candidateSeq === undefined && existingSeq !== undefined) {
+            continue;
+        }
+        if (candidate.order < existing.order) {
+            byUpdateId.set(updateId, candidate);
+        }
+    }
+    return [...byUpdateId.values()]
+        .sort((left, right) => {
+        const leftSeq = left.sequencing;
+        const rightSeq = right.sequencing;
+        if (leftSeq !== undefined && rightSeq !== undefined) {
+            if (leftSeq < rightSeq) {
+                return -1;
+            }
+            if (leftSeq > rightSeq) {
+                return 1;
+            }
+        }
+        else if (leftSeq !== undefined) {
+            return -1;
+        }
+        else if (rightSeq !== undefined) {
+            return 1;
+        }
+        return left.order - right.order;
+    })
+        .map((entry) => entry.invocation);
 };
 const buildUpdateInvocationFromRequest = async (input) => {
     const req = input.request;
@@ -807,6 +1386,49 @@ const normalizeUpdateInvocationPayload = (values) => {
     return values;
 };
 const decodePayloadArray = (converter, payloads) => Effect.tryPromise(async () => await decodePayloadsToValues(converter, payloads?.payloads ?? []));
+const decodeMarkerDetails = (converter, details) => Effect.tryPromise(async () => {
+    if (!details || Object.keys(details).length === 0) {
+        return undefined;
+    }
+    const decoded = {};
+    for (const [key, payloads] of Object.entries(details)) {
+        const values = await decodePayloadsToValues(converter, payloads?.payloads ?? []);
+        if (values.length === 0) {
+            continue;
+        }
+        decoded[key] = values.length === 1 ? values[0] : values;
+    }
+    return Object.keys(decoded).length > 0 ? decoded : undefined;
+});
+const decodeSearchAttributes = (converter, input) => Effect.tryPromise(async () => {
+    const fields = input?.indexedFields;
+    if (!fields || Object.keys(fields).length === 0) {
+        return undefined;
+    }
+    const decoded = {};
+    for (const [key, payload] of Object.entries(fields)) {
+        const values = await decodePayloadsToValues(converter, payload ? [payload] : []);
+        if (values.length === 0) {
+            continue;
+        }
+        decoded[key] = values.length === 1 ? values[0] : values;
+    }
+    return decoded;
+});
+const decodeMemo = (converter, memo) => Effect.tryPromise(async () => {
+    const decoded = {};
+    const fields = memo?.fields ?? {};
+    for (const [key, payload] of Object.entries(fields)) {
+        const values = await decodePayloadsToValues(converter, payload ? [payload] : []);
+        if (values.length === 0) {
+            decoded[key] = undefined;
+        }
+        else {
+            decoded[key] = values.length === 1 ? values[0] : values;
+        }
+    }
+    return decoded;
+});
 const convertRetryPolicy = (policy) => {
     if (!policy) {
         return undefined;
@@ -870,19 +1492,63 @@ const resolveOutcomeStatus = (outcome) => {
     }
     return undefined;
 };
+const applyDeterminismDelta = (state, delta) => ({
+    ...state,
+    commandHistory: [...state.commandHistory, ...(delta.commandHistory ?? [])],
+    randomValues: [...state.randomValues, ...(delta.randomValues ?? [])],
+    timeValues: [...state.timeValues, ...(delta.timeValues ?? [])],
+    signals: [...state.signals, ...(delta.signals ?? [])],
+    queries: [...state.queries, ...(delta.queries ?? [])],
+    ...(delta.updates
+        ? { updates: [...(state.updates ?? []), ...(delta.updates ?? [])] }
+        : state.updates
+            ? { updates: [...state.updates] }
+            : {}),
+    ...(delta.logCount !== undefined ? { logCount: delta.logCount } : {}),
+    ...(delta.failureMetadata ? { failureMetadata: delta.failureMetadata } : {}),
+});
+const applyDeterminismMarker = (state, marker) => {
+    if (marker.schemaVersion === 1) {
+        return marker.determinismState;
+    }
+    const base = marker.determinismState ?? state;
+    if (!base) {
+        return undefined;
+    }
+    if (!marker.determinismDelta) {
+        return base;
+    }
+    return applyDeterminismDelta(base, marker.determinismDelta);
+};
 const sanitizeDeterminismMarkerEnvelope = (input) => {
     const schemaVersion = input.schemaVersion;
-    if (schemaVersion !== DETERMINISM_MARKER_SCHEMA_VERSION) {
+    if (schemaVersion !== DETERMINISM_MARKER_SCHEMA_VERSION_V1 &&
+        schemaVersion !== DETERMINISM_MARKER_SCHEMA_VERSION_V2) {
         throw new Error(`Unsupported determinism marker schema version: ${String(schemaVersion)}`);
     }
     const workflow = sanitizeWorkflowInfo(input.workflow);
-    const determinismState = sanitizeDeterminismState(input.determinismState);
     const lastEventId = normalizeEventId(input.lastEventId);
     const recordedAt = sanitizeRecordedAt(input.recordedAtIso);
+    if (schemaVersion === DETERMINISM_MARKER_SCHEMA_VERSION_V1) {
+        const determinismState = sanitizeDeterminismState(input.determinismState);
+        return {
+            schemaVersion: DETERMINISM_MARKER_SCHEMA_VERSION_V1,
+            workflow,
+            determinismState,
+            lastEventId,
+            recordedAtIso: recordedAt,
+        };
+    }
+    const determinismState = input.determinismState !== undefined ? sanitizeDeterminismState(input.determinismState) : undefined;
+    const determinismDelta = input.determinismDelta !== undefined ? sanitizeDeterminismDelta(input.determinismDelta) : undefined;
+    if (!determinismState && !determinismDelta) {
+        throw new Error('Determinism marker missing determinism state or delta');
+    }
     return {
-        schemaVersion: DETERMINISM_MARKER_SCHEMA_VERSION,
+        schemaVersion: DETERMINISM_MARKER_SCHEMA_VERSION_V2,
         workflow,
-        determinismState,
+        ...(determinismState ? { determinismState } : {}),
+        ...(determinismDelta ? { determinismDelta } : {}),
         lastEventId,
         recordedAtIso: recordedAt,
     };
@@ -906,6 +1572,7 @@ const sanitizeDeterminismState = (value) => {
     const commandHistoryRaw = value.commandHistory;
     const randomValuesRaw = value.randomValues;
     const timeValuesRaw = value.timeValues;
+    const logCountRaw = value.logCount;
     const signalsRaw = Array.isArray(value.signals) ? value.signals : [];
     const queriesRaw = Array.isArray(value.queries) ? value.queries : [];
     const updatesRaw = value.updates;
@@ -924,6 +1591,7 @@ const sanitizeDeterminismState = (value) => {
     });
     const randomValues = randomValuesRaw.map((val, index) => coerceNumber(val, `determinism.randomValues[${index}]`));
     const timeValues = timeValuesRaw.map((val, index) => coerceNumber(val, `determinism.timeValues[${index}]`));
+    const logCount = coerceOptionalNumber(logCountRaw, 'determinism.logCount');
     const failureMetadata = sanitizeFailureMetadata(value.failureMetadata);
     const signals = signalsRaw.map((record, index) => sanitizeSignalRecord(record, index));
     const queries = queriesRaw.map((record, index) => sanitizeQueryRecord(record, index));
@@ -932,12 +1600,40 @@ const sanitizeDeterminismState = (value) => {
         commandHistory,
         randomValues,
         timeValues,
+        ...(logCount !== undefined ? { logCount } : {}),
         ...(failureMetadata ? { failureMetadata } : {}),
         signals,
         queries,
         ...(updates ? { updates } : {}),
     };
 };
+const sanitizeDeterminismDelta = (value) => {
+    if (!isRecord(value)) {
+        throw new Error('Determinism marker contained invalid determinism delta');
+    }
+    const commandHistoryRaw = value.commandHistory ?? [];
+    const randomValuesRaw = value.randomValues ?? [];
+    const timeValuesRaw = value.timeValues ?? [];
+    const signalsRaw = value.signals ?? [];
+    const queriesRaw = value.queries ?? [];
+    if (!Array.isArray(commandHistoryRaw) ||
+        !Array.isArray(randomValuesRaw) ||
+        !Array.isArray(timeValuesRaw) ||
+        !Array.isArray(signalsRaw) ||
+        !Array.isArray(queriesRaw)) {
+        throw new Error('Determinism marker contained invalid determinism delta shape');
+    }
+    return sanitizeDeterminismState({
+        commandHistory: commandHistoryRaw,
+        randomValues: randomValuesRaw,
+        timeValues: timeValuesRaw,
+        signals: signalsRaw,
+        queries: queriesRaw,
+        ...(value.updates !== undefined ? { updates: value.updates } : {}),
+        ...(value.logCount !== undefined ? { logCount: value.logCount } : {}),
+        ...(value.failureMetadata !== undefined ? { failureMetadata: value.failureMetadata } : {}),
+    });
+};
 const sanitizeCommandMetadata = (value, index) => {
     if (value === undefined || value === null) {
         return undefined;