@proompteng/temporal-bun-sdk 0.1.0

package/dist/src/workflow/replay.js

@@ -0,0 +1,759 @@
+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 { EventType } from '../proto/temporal/api/enums/v1/event_type_pb';
+import { ParentClosePolicy, TimeoutType, WorkflowIdReusePolicy } from '../proto/temporal/api/enums/v1/workflow_pb';
+import { intentsEqual } from './determinism';
+export const DETERMINISM_MARKER_NAME = 'temporal-bun-sdk/determinism';
+const DETERMINISM_MARKER_SCHEMA_VERSION = 1;
+const DETERMINISM_MARKER_DETAIL_KEY = 'snapshot';
+/**
+ * Encode a workflow determinism snapshot into a marker payload map suitable for
+ * use with {@link RecordMarkerCommandAttributes.details}.
+ */
+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 payloads = await encodeValuesToPayloads(converter, [envelope]);
+    if (!payloads || payloads.length === 0) {
+        throw new Error('Failed to encode determinism marker payloads');
+    }
+    return {
+        [DETERMINISM_MARKER_DETAIL_KEY]: create(PayloadsSchema, { payloads }),
+    };
+});
+/**
+ * Decode determinism snapshot metadata from a marker payload map. Returns
+ * `undefined` when the supplied details do not contain a determinism snapshot.
+ */
+export const decodeDeterminismMarkerEnvelope = (input) => Effect.tryPromise(async () => {
+    const snapshot = input.details?.[DETERMINISM_MARKER_DETAIL_KEY];
+    if (!snapshot) {
+        return undefined;
+    }
+    const values = await decodePayloadsToValues(input.converter, snapshot.payloads ?? []);
+    if (!values || values.length === 0) {
+        return undefined;
+    }
+    const envelope = values[0];
+    if (!isRecord(envelope)) {
+        throw new Error('Determinism marker payload was not an object');
+    }
+    return sanitizeDeterminismMarkerEnvelope(envelope);
+});
+/**
+ * Processes workflow history into a determinism snapshot that can seed the
+ * {@link DeterminismGuard}. Downstream tasks populate sticky caches and replay
+ * diagnostics from the returned state.
+ */
+export const ingestWorkflowHistory = (intake) => Effect.gen(function* () {
+    const events = sortHistoryEvents(intake.history ?? []);
+    const shouldUseDeterminismMarker = intake.ignoreDeterminismMarker !== true;
+    let markerSnapshot;
+    if (shouldUseDeterminismMarker) {
+        for (const event of events) {
+            if (event.eventType !== EventType.MARKER_RECORDED) {
+                continue;
+            }
+            if (event.attributes?.case !== 'markerRecordedEventAttributes') {
+                continue;
+            }
+            const decoded = yield* Effect.catchAll(decodeDeterminismMarkerEnvelope({
+                converter: intake.dataConverter,
+                details: event.attributes.value.details,
+            }), () => Effect.succeed(undefined));
+            if (decoded) {
+                markerSnapshot = decoded;
+            }
+        }
+    }
+    const extractedFailureMetadata = extractFailureMetadata(events);
+    if (shouldUseDeterminismMarker && markerSnapshot) {
+        const determinismState = markerSnapshot.determinismState.failureMetadata
+            ? markerSnapshot.determinismState
+            : {
+                ...markerSnapshot.determinismState,
+                ...(extractedFailureMetadata ? { failureMetadata: extractedFailureMetadata } : {}),
+            };
+        const latestEventId = resolveHistoryLastEventId(events) ?? markerSnapshot.lastEventId ?? null;
+        return {
+            determinismState,
+            lastEventId: latestEventId,
+            hasDeterminismMarker: true,
+        };
+    }
+    return yield* reconstructDeterminismState(events, intake, extractedFailureMetadata);
+});
+/**
+ * Diff determinism state against freshly emitted intents to produce rich
+ * diagnostics for `WorkflowNondeterminismError` instances.
+ */
+export const diffDeterminismState = (expected, actual) => Effect.sync(() => {
+    const mismatches = [];
+    const maxCommands = Math.max(expected.commandHistory.length, actual.commandHistory.length);
+    for (let index = 0; index < maxCommands; index += 1) {
+        const expectedEntry = expected.commandHistory[index];
+        const actualEntry = actual.commandHistory[index];
+        const expectedIntent = expectedEntry?.intent;
+        const actualIntent = actualEntry?.intent;
+        const metadata = resolveCommandMismatchMetadata(expectedEntry, actualEntry);
+        if (!expectedIntent || !actualIntent) {
+            if (expectedIntent !== actualIntent) {
+                mismatches.push({
+                    kind: 'command',
+                    index,
+                    expected: expectedIntent,
+                    actual: actualIntent,
+                    ...metadata,
+                });
+            }
+            continue;
+        }
+        if (!intentsEqual(expectedIntent, actualIntent)) {
+            mismatches.push({
+                kind: 'command',
+                index,
+                expected: expectedIntent,
+                actual: actualIntent,
+                ...metadata,
+            });
+        }
+    }
+    const maxRandom = Math.max(expected.randomValues.length, actual.randomValues.length);
+    for (let index = 0; index < maxRandom; index += 1) {
+        const expectedValue = expected.randomValues[index];
+        const actualValue = actual.randomValues[index];
+        if (!valuesEqual(expectedValue, actualValue)) {
+            mismatches.push({
+                kind: 'random',
+                index,
+                expected: expectedValue,
+                actual: actualValue,
+            });
+        }
+    }
+    const maxTime = Math.max(expected.timeValues.length, actual.timeValues.length);
+    for (let index = 0; index < maxTime; index += 1) {
+        const expectedValue = expected.timeValues[index];
+        const actualValue = actual.timeValues[index];
+        if (!valuesEqual(expectedValue, actualValue)) {
+            mismatches.push({
+                kind: 'time',
+                index,
+                expected: expectedValue,
+                actual: actualValue,
+            });
+        }
+    }
+    return { mismatches };
+});
+export const resolveHistoryLastEventId = (events) => {
+    if (!events || events.length === 0) {
+        return null;
+    }
+    const last = events[events.length - 1];
+    if (!last) {
+        return null;
+    }
+    const { eventId } = last;
+    if (eventId === undefined || eventId === null) {
+        return null;
+    }
+    if (typeof eventId === 'number' && !Number.isFinite(eventId)) {
+        return null;
+    }
+    return String(eventId);
+};
+export const cloneDeterminismState = (state) => ({
+    commandHistory: state.commandHistory.map((entry) => ({
+        intent: entry.intent,
+        metadata: entry.metadata ? { ...entry.metadata } : undefined,
+    })),
+    randomValues: [...state.randomValues],
+    timeValues: [...state.timeValues],
+    failureMetadata: state.failureMetadata ? { ...state.failureMetadata } : undefined,
+});
+const sortHistoryEvents = (events) => events.slice().sort((left, right) => {
+    const leftId = resolveEventIdForSort(left);
+    const rightId = resolveEventIdForSort(right);
+    if (leftId === rightId) {
+        return 0;
+    }
+    return leftId < rightId ? -1 : 1;
+});
+const resolveEventIdForSort = (event) => {
+    const eventId = event.eventId;
+    if (typeof eventId === 'bigint') {
+        return eventId;
+    }
+    if (typeof eventId === 'number' && Number.isFinite(eventId)) {
+        return BigInt(eventId);
+    }
+    if (typeof eventId === 'string' && eventId.length > 0) {
+        try {
+            return BigInt(eventId);
+        }
+        catch {
+            return 0n;
+        }
+    }
+    return 0n;
+};
+const buildCommandMetadata = (event, attributes) => {
+    const eventId = normalizeEventId(event.eventId);
+    const workflowTaskCompletedEventId = resolveWorkflowTaskCompletedEventId(attributes);
+    const eventType = event.eventType;
+    if (!eventId && !workflowTaskCompletedEventId && (eventType === undefined || eventType === EventType.UNSPECIFIED)) {
+        return undefined;
+    }
+    return {
+        ...(eventId !== null ? { eventId } : {}),
+        ...(typeof eventType === 'number' ? { eventType } : {}),
+        ...(workflowTaskCompletedEventId ? { workflowTaskCompletedEventId } : {}),
+    };
+};
+const resolveWorkflowTaskCompletedEventId = (attributes) => {
+    if (!attributes || typeof attributes !== 'object') {
+        return null;
+    }
+    const candidate = attributes.workflowTaskCompletedEventId;
+    if (candidate === undefined || candidate === null) {
+        return null;
+    }
+    try {
+        return normalizeEventId(candidate);
+    }
+    catch {
+        return null;
+    }
+};
+const extractFailureMetadata = (events) => {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const metadata = buildFailureMetadata(events[index]);
+        if (metadata) {
+            return metadata;
+        }
+    }
+    return undefined;
+};
+const buildFailureMetadata = (event) => {
+    const eventId = normalizeEventId(event.eventId);
+    switch (event.eventType) {
+        case EventType.WORKFLOW_EXECUTION_FAILED: {
+            if (event.attributes?.case !== 'workflowExecutionFailedEventAttributes') {
+                return undefined;
+            }
+            const attributes = event.attributes.value;
+            return {
+                eventId,
+                eventType: event.eventType,
+                failureType: resolveFailureType(attributes.failure),
+                failureMessage: attributes.failure?.message ?? undefined,
+                retryState: attributes.retryState !== undefined ? Number(attributes.retryState) : undefined,
+            };
+        }
+        case EventType.WORKFLOW_EXECUTION_TIMED_OUT: {
+            if (event.attributes?.case !== 'workflowExecutionTimedOutEventAttributes') {
+                return undefined;
+            }
+            const attributes = event.attributes.value;
+            return {
+                eventId,
+                eventType: event.eventType,
+                failureType: 'WORKFLOW_EXECUTION_TIMED_OUT',
+                failureMessage: undefined,
+                retryState: attributes.retryState !== undefined ? Number(attributes.retryState) : undefined,
+            };
+        }
+        case EventType.WORKFLOW_TASK_FAILED: {
+            if (event.attributes?.case !== 'workflowTaskFailedEventAttributes') {
+                return undefined;
+            }
+            const attributes = event.attributes.value;
+            return {
+                eventId,
+                eventType: event.eventType,
+                failureType: resolveFailureType(attributes.failure),
+                failureMessage: attributes.failure?.message ?? undefined,
+            };
+        }
+        case EventType.WORKFLOW_TASK_TIMED_OUT: {
+            if (event.attributes?.case !== 'workflowTaskTimedOutEventAttributes') {
+                return undefined;
+            }
+            const attributes = event.attributes.value;
+            const timeoutTypeName = TimeoutType[attributes.timeoutType] ?? 'TIMEOUT_TYPE_UNSPECIFIED';
+            return {
+                eventId,
+                eventType: event.eventType,
+                failureType: `WORKFLOW_TASK_TIMED_OUT:${timeoutTypeName}`,
+            };
+        }
+        default:
+            return undefined;
+    }
+};
+const resolveFailureType = (failure) => {
+    if (!failure) {
+        return undefined;
+    }
+    switch (failure.failureInfo?.case) {
+        case 'applicationFailureInfo':
+            return failure.failureInfo.value.type || 'ApplicationFailure';
+        case 'timeoutFailureInfo': {
+            const timeoutName = TimeoutType[failure.failureInfo.value.timeoutType] ?? 'TIMEOUT_TYPE_UNSPECIFIED';
+            return `Timeout:${timeoutName}`;
+        }
+        case 'activityFailureInfo':
+            return 'ActivityFailure';
+        case 'childWorkflowExecutionFailureInfo':
+            return 'ChildWorkflowFailure';
+        case 'canceledFailureInfo':
+            return 'CanceledFailure';
+        case 'terminatedFailureInfo':
+            return 'TerminatedFailure';
+        case 'serverFailureInfo':
+            return 'ServerFailure';
+        case 'resetWorkflowFailureInfo':
+            return 'ResetWorkflowFailure';
+        default:
+            return failure.failureInfo?.case ?? failure.source ?? failure.message ?? undefined;
+    }
+};
+const resolveCommandMismatchMetadata = (expectedEntry, actualEntry) => {
+    const expectedMetadata = expectedEntry?.metadata;
+    const actualMetadata = actualEntry?.metadata;
+    const workflowTaskCompletedEventId = expectedMetadata?.workflowTaskCompletedEventId ?? actualMetadata?.workflowTaskCompletedEventId ?? null;
+    const eventType = expectedMetadata?.eventType ?? actualMetadata?.eventType;
+    return {
+        expectedEventId: expectedMetadata?.eventId ?? null,
+        actualEventId: actualMetadata?.eventId ?? null,
+        workflowTaskCompletedEventId,
+        eventType,
+    };
+};
+const reconstructDeterminismState = (events, intake, failureMetadata) => Effect.gen(function* () {
+    let sequence = 0;
+    const commandHistory = [];
+    for (const event of events) {
+        switch (event.eventType) {
+            case EventType.ACTIVITY_TASK_SCHEDULED: {
+                if (event.attributes?.case !== 'activityTaskScheduledEventAttributes') {
+                    break;
+                }
+                const intent = yield* fromActivityTaskScheduled(event.attributes.value, sequence, intake);
+                if (intent) {
+                    commandHistory.push({
+                        intent,
+                        metadata: buildCommandMetadata(event, event.attributes.value),
+                    });
+                    sequence += 1;
+                }
+                break;
+            }
+            case EventType.TIMER_STARTED: {
+                if (event.attributes?.case !== 'timerStartedEventAttributes') {
+                    break;
+                }
+                const intent = fromTimerStarted(event.attributes.value, sequence);
+                if (intent) {
+                    commandHistory.push({
+                        intent,
+                        metadata: buildCommandMetadata(event, event.attributes.value),
+                    });
+                    sequence += 1;
+                }
+                break;
+            }
+            case EventType.START_CHILD_WORKFLOW_EXECUTION_INITIATED: {
+                if (event.attributes?.case !== 'startChildWorkflowExecutionInitiatedEventAttributes') {
+                    break;
+                }
+                const intent = yield* fromStartChildWorkflow(event.attributes.value, sequence, intake);
+                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;
+                }
+                const intent = yield* fromSignalExternalWorkflow(event.attributes.value, sequence, intake);
+                if (intent) {
+                    commandHistory.push({
+                        intent,
+                        metadata: buildCommandMetadata(event, event.attributes.value),
+                    });
+                    sequence += 1;
+                }
+                break;
+            }
+            case EventType.WORKFLOW_EXECUTION_CONTINUED_AS_NEW: {
+                if (event.attributes?.case !== 'workflowExecutionContinuedAsNewEventAttributes') {
+                    break;
+                }
+                const intent = yield* fromContinueAsNew(event.attributes.value, sequence, intake);
+                if (intent) {
+                    commandHistory.push({
+                        intent,
+                        metadata: buildCommandMetadata(event, event.attributes.value),
+                    });
+                    sequence += 1;
+                }
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return {
+        determinismState: {
+            commandHistory,
+            randomValues: [],
+            timeValues: [],
+            ...(failureMetadata ? { failureMetadata } : {}),
+        },
+        lastEventId: resolveHistoryLastEventId(events),
+        hasDeterminismMarker: false,
+    };
+});
+const fromActivityTaskScheduled = (attributes, sequence, intake) => Effect.gen(function* () {
+    const activityType = attributes.activityType?.name;
+    if (!activityType) {
+        return undefined;
+    }
+    const input = yield* decodePayloadArray(intake.dataConverter, attributes.input);
+    const eagerAttributes = attributes;
+    const intent = {
+        id: `schedule-activity-${sequence}`,
+        kind: 'schedule-activity',
+        sequence,
+        activityType,
+        activityId: attributes.activityId || `activity-${sequence}`,
+        taskQueue: attributes.taskQueue?.name ?? intake.info.taskQueue,
+        input,
+        header: attributes.header,
+        timeouts: {
+            scheduleToCloseTimeoutMs: durationToMillis(attributes.scheduleToCloseTimeout),
+            scheduleToStartTimeoutMs: durationToMillis(attributes.scheduleToStartTimeout),
+            startToCloseTimeoutMs: durationToMillis(attributes.startToCloseTimeout),
+            heartbeatTimeoutMs: durationToMillis(attributes.heartbeatTimeout),
+        },
+        retry: convertRetryPolicy(attributes.retryPolicy),
+        requestEagerExecution: eagerAttributes.requestEagerExecution ?? undefined,
+    };
+    return intent;
+});
+const fromTimerStarted = (attributes, sequence) => {
+    const timeout = durationToMillis(attributes.startToFireTimeout);
+    if (timeout === undefined) {
+        return undefined;
+    }
+    const timerId = attributes.timerId || `timer-${sequence}`;
+    return {
+        id: `start-timer-${sequence}`,
+        kind: 'start-timer',
+        sequence,
+        timerId,
+        timeoutMs: timeout,
+    };
+};
+const fromStartChildWorkflow = (attributes, sequence, intake) => Effect.gen(function* () {
+    const workflowType = attributes.workflowType?.name;
+    if (!workflowType) {
+        return undefined;
+    }
+    const input = yield* decodePayloadArray(intake.dataConverter, attributes.input);
+    const parentClosePolicy = attributes.parentClosePolicy !== undefined && attributes.parentClosePolicy !== ParentClosePolicy.UNSPECIFIED
+        ? attributes.parentClosePolicy
+        : undefined;
+    const workflowIdReusePolicy = attributes.workflowIdReusePolicy !== undefined &&
+        attributes.workflowIdReusePolicy !== WorkflowIdReusePolicy.UNSPECIFIED
+        ? attributes.workflowIdReusePolicy
+        : undefined;
+    const intent = {
+        id: `start-child-workflow-${sequence}`,
+        kind: 'start-child-workflow',
+        sequence,
+        workflowType,
+        workflowId: attributes.workflowId || `${intake.info.workflowId}-child-${sequence}`,
+        namespace: attributes.namespace || intake.info.namespace,
+        taskQueue: attributes.taskQueue?.name ?? intake.info.taskQueue,
+        input,
+        timeouts: {
+            workflowExecutionTimeoutMs: durationToMillis(attributes.workflowExecutionTimeout),
+            workflowRunTimeoutMs: durationToMillis(attributes.workflowRunTimeout),
+            workflowTaskTimeoutMs: durationToMillis(attributes.workflowTaskTimeout),
+        },
+        parentClosePolicy,
+        workflowIdReusePolicy,
+        retry: convertRetryPolicy(attributes.retryPolicy),
+        cronSchedule: attributes.cronSchedule || undefined,
+        header: attributes.header,
+        memo: attributes.memo,
+        searchAttributes: attributes.searchAttributes,
+    };
+    return intent;
+});
+const fromSignalExternalWorkflow = (attributes, sequence, intake) => Effect.gen(function* () {
+    if (!attributes.signalName) {
+        return undefined;
+    }
+    const input = yield* decodePayloadArray(intake.dataConverter, attributes.input);
+    const intent = {
+        id: `signal-external-${sequence}`,
+        kind: 'signal-external-workflow',
+        sequence,
+        namespace: attributes.namespace || intake.info.namespace,
+        workflowId: attributes.workflowExecution?.workflowId ?? intake.info.workflowId,
+        runId: attributes.workflowExecution?.runId || undefined,
+        signalName: attributes.signalName,
+        input,
+        childWorkflowOnly: attributes.childWorkflowOnly ?? false,
+        header: attributes.header,
+    };
+    return intent;
+});
+const fromContinueAsNew = (attributes, sequence, intake) => Effect.gen(function* () {
+    const input = yield* decodePayloadArray(intake.dataConverter, attributes.input);
+    const extendedAttributes = attributes;
+    const intent = {
+        id: `continue-as-new-${sequence}`,
+        kind: 'continue-as-new',
+        sequence,
+        workflowType: attributes.workflowType?.name ?? intake.info.workflowType,
+        taskQueue: attributes.taskQueue?.name ?? intake.info.taskQueue,
+        input,
+        timeouts: {
+            workflowRunTimeoutMs: durationToMillis(attributes.workflowRunTimeout),
+            workflowTaskTimeoutMs: durationToMillis(attributes.workflowTaskTimeout),
+        },
+        backoffStartIntervalMs: durationToMillis(attributes.backoffStartInterval),
+        retry: convertRetryPolicy(extendedAttributes.retryPolicy),
+        memo: attributes.memo,
+        searchAttributes: attributes.searchAttributes,
+        header: attributes.header,
+        cronSchedule: extendedAttributes.cronSchedule || undefined,
+    };
+    return intent;
+});
+const decodePayloadArray = (converter, payloads) => Effect.tryPromise(async () => await decodePayloadsToValues(converter, payloads?.payloads ?? []));
+const 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 } : {}),
+    };
+};
+const sanitizeDeterminismMarkerEnvelope = (input) => {
+    const schemaVersion = input.schemaVersion;
+    if (schemaVersion !== DETERMINISM_MARKER_SCHEMA_VERSION) {
+        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);
+    return {
+        schemaVersion: DETERMINISM_MARKER_SCHEMA_VERSION,
+        workflow,
+        determinismState,
+        lastEventId,
+        recordedAtIso: recordedAt,
+    };
+};
+const sanitizeWorkflowInfo = (value) => {
+    if (!isRecord(value)) {
+        throw new Error('Determinism marker missing workflow metadata');
+    }
+    return {
+        namespace: coerceString(value.namespace, 'workflow.namespace'),
+        taskQueue: coerceString(value.taskQueue, 'workflow.taskQueue'),
+        workflowId: coerceString(value.workflowId, 'workflow.workflowId'),
+        runId: coerceString(value.runId, 'workflow.runId'),
+        workflowType: coerceString(value.workflowType, 'workflow.workflowType'),
+    };
+};
+const sanitizeDeterminismState = (value) => {
+    if (!isRecord(value)) {
+        throw new Error('Determinism marker missing determinism state');
+    }
+    const commandHistoryRaw = value.commandHistory;
+    const randomValuesRaw = value.randomValues;
+    const timeValuesRaw = value.timeValues;
+    if (!Array.isArray(commandHistoryRaw) || !Array.isArray(randomValuesRaw) || !Array.isArray(timeValuesRaw)) {
+        throw new Error('Determinism marker contained invalid determinism state shape');
+    }
+    const commandHistory = commandHistoryRaw.map((entry, index) => {
+        if (!isRecord(entry) || entry.intent === undefined) {
+            throw new Error(`Determinism marker command history entry ${index} is invalid`);
+        }
+        const metadata = sanitizeCommandMetadata(entry.metadata, index);
+        return {
+            intent: entry.intent,
+            ...(metadata ? { metadata } : {}),
+        };
+    });
+    const randomValues = randomValuesRaw.map((val, index) => coerceNumber(val, `determinism.randomValues[${index}]`));
+    const timeValues = timeValuesRaw.map((val, index) => coerceNumber(val, `determinism.timeValues[${index}]`));
+    const failureMetadata = sanitizeFailureMetadata(value.failureMetadata);
+    return {
+        commandHistory,
+        randomValues,
+        timeValues,
+        ...(failureMetadata ? { failureMetadata } : {}),
+    };
+};
+const sanitizeCommandMetadata = (value, index) => {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (!isRecord(value)) {
+        throw new Error(`Determinism marker command history entry ${index} metadata is invalid`);
+    }
+    const eventId = normalizeOptionalEventId(value.eventId, `determinism.commandHistory[${index}].metadata.eventId`);
+    const workflowTaskCompletedEventId = normalizeOptionalEventId(value.workflowTaskCompletedEventId, `determinism.commandHistory[${index}].metadata.workflowTaskCompletedEventId`);
+    const eventTypeValue = value.eventType;
+    const eventType = typeof eventTypeValue === 'number' && Number.isFinite(eventTypeValue) ? eventTypeValue : undefined;
+    const hasMetadata = eventId || workflowTaskCompletedEventId || eventType !== undefined;
+    if (!hasMetadata) {
+        return undefined;
+    }
+    return {
+        ...(eventId ? { eventId } : {}),
+        ...(workflowTaskCompletedEventId ? { workflowTaskCompletedEventId } : {}),
+        ...(eventType !== undefined ? { eventType } : {}),
+    };
+};
+const sanitizeFailureMetadata = (value) => {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (!isRecord(value)) {
+        throw new Error('Determinism marker contained invalid failure metadata');
+    }
+    const eventId = normalizeOptionalEventId(value.eventId, 'determinism.failureMetadata.eventId');
+    const failureType = coerceOptionalString(value.failureType, 'determinism.failureMetadata.failureType');
+    const failureMessage = coerceOptionalString(value.failureMessage, 'determinism.failureMetadata.failureMessage');
+    const workflowEventType = typeof value.eventType === 'number' && Number.isFinite(value.eventType) ? value.eventType : undefined;
+    const retryState = coerceOptionalNumber(value.retryState, 'determinism.failureMetadata.retryState');
+    if (!eventId && !failureType && !failureMessage && workflowEventType === undefined && retryState === undefined) {
+        return undefined;
+    }
+    return {
+        ...(eventId ? { eventId } : {}),
+        ...(workflowEventType !== undefined ? { eventType: workflowEventType } : {}),
+        ...(failureType ? { failureType } : {}),
+        ...(failureMessage ? { failureMessage } : {}),
+        ...(retryState !== undefined ? { retryState } : {}),
+    };
+};
+const sanitizeRecordedAt = (value) => {
+    if (typeof value === 'string' && value.length > 0) {
+        return value;
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    throw new Error('Determinism marker missing recordedAt timestamp');
+};
+const normalizeEventId = (value) => {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (typeof value === 'string' && value.length > 0) {
+        return value;
+    }
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value.toString();
+    }
+    if (typeof value === 'bigint') {
+        return value.toString();
+    }
+    throw new Error(`Determinism marker contained invalid lastEventId: ${String(value)}`);
+};
+const coerceString = (value, label) => {
+    if (typeof value === 'string' && value.length > 0) {
+        return value;
+    }
+    throw new Error(`Determinism marker missing ${label}`);
+};
+const coerceOptionalString = (value, label) => {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value !== 'string') {
+        throw new Error(`Determinism marker contained invalid ${label}`);
+    }
+    return value.length > 0 ? value : undefined;
+};
+const coerceNumber = (value, label) => {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'bigint') {
+        const numeric = Number(value);
+        if (Number.isFinite(numeric)) {
+            return numeric;
+        }
+    }
+    throw new Error(`Determinism marker contained non-finite ${label}`);
+};
+const coerceOptionalNumber = (value, label) => {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    return coerceNumber(value, label);
+};
+const normalizeOptionalEventId = (value, label) => {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    try {
+        return normalizeEventId(value) ?? undefined;
+    }
+    catch {
+        throw new Error(`Determinism marker contained invalid ${label}`);
+    }
+};
+const valuesEqual = (expected, actual) => {
+    if (expected === undefined && actual === undefined) {
+        return true;
+    }
+    if (expected === undefined || actual === undefined) {
+        return false;
+    }
+    return Object.is(expected, actual);
+};
+const isRecord = (value) => typeof value === 'object' && value !== null;
+//# sourceMappingURL=replay.js.map