@proompteng/temporal-bun-sdk 0.2.0 → 0.3.0

package/dist/src/workflow/replay.js

@@ -5,7 +5,7 @@ import { decodePayloadsToValues, encodeValuesToPayloads } from '../common/payloa
 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';
+import { intentsEqual, stableStringify } from './determinism';
 export const DETERMINISM_MARKER_NAME = 'temporal-bun-sdk/determinism';
 const DETERMINISM_MARKER_SCHEMA_VERSION = 1;
 const DETERMINISM_MARKER_DETAIL_KEY = 'snapshot';
@@ -58,6 +58,7 @@ export const ingestWorkflowHistory = (intake) => Effect.gen(function* () {
     const events = sortHistoryEvents(intake.history ?? []);
     const shouldUseDeterminismMarker = intake.ignoreDeterminismMarker !== true;
     let markerSnapshot;
+    const updateEntries = collectWorkflowUpdateEntries(events);
     if (shouldUseDeterminismMarker) {
         for (const event of events) {
             if (event.eventType !== EventType.MARKER_RECORDED) {
@@ -76,21 +77,31 @@ export const ingestWorkflowHistory = (intake) => Effect.gen(function* () {
         }
     }
     const extractedFailureMetadata = extractFailureMetadata(events);
+    const replayUpdateInvocations = yield* Effect.tryPromise(async () => collectWorkflowUpdateInvocations(events, intake.dataConverter));
     if (shouldUseDeterminismMarker && markerSnapshot) {
-        const determinismState = markerSnapshot.determinismState.failureMetadata
-            ? markerSnapshot.determinismState
-            : {
-                ...markerSnapshot.determinismState,
-                ...(extractedFailureMetadata ? { failureMetadata: extractedFailureMetadata } : {}),
+        let determinismState = cloneDeterminismState(markerSnapshot.determinismState);
+        if (!determinismState.failureMetadata && extractedFailureMetadata) {
+            determinismState = {
+                ...determinismState,
+                failureMetadata: extractedFailureMetadata,
             };
+        }
+        if ((!determinismState.updates || determinismState.updates.length === 0) && updateEntries.length > 0) {
+            determinismState = {
+                ...determinismState,
+                updates: updateEntries,
+            };
+        }
+        determinismState = mergePendingQueryRequests(determinismState, intake.queries);
         const latestEventId = resolveHistoryLastEventId(events) ?? markerSnapshot.lastEventId ?? null;
         return {
             determinismState,
             lastEventId: latestEventId,
             hasDeterminismMarker: true,
+            ...(replayUpdateInvocations.length > 0 ? { updates: replayUpdateInvocations } : {}),
         };
     }
-    return yield* reconstructDeterminismState(events, intake, extractedFailureMetadata);
+    return yield* reconstructDeterminismState(events, intake, extractedFailureMetadata, updateEntries, replayUpdateInvocations);
 });
 /**
  * Diff determinism state against freshly emitted intents to produce rich
@@ -153,6 +164,36 @@ export const diffDeterminismState = (expected, actual) => Effect.sync(() => {
             });
         }
     }
+    const expectedSignals = expected.signals ?? [];
+    const actualSignals = actual.signals ?? [];
+    const maxSignals = Math.max(expectedSignals.length, actualSignals.length);
+    for (let index = 0; index < maxSignals; index += 1) {
+        const expectedSignal = expectedSignals[index];
+        const actualSignal = actualSignals[index];
+        if (!recordsMatch(expectedSignal, actualSignal)) {
+            mismatches.push({ kind: 'signal', index, expected: expectedSignal, actual: actualSignal });
+        }
+    }
+    const expectedQueries = expected.queries ?? [];
+    const actualQueries = actual.queries ?? [];
+    const maxQueries = Math.max(expectedQueries.length, actualQueries.length);
+    for (let index = 0; index < maxQueries; index += 1) {
+        const expectedQuery = expectedQueries[index];
+        const actualQuery = actualQueries[index];
+        if (!recordsMatch(expectedQuery, actualQuery)) {
+            mismatches.push({ kind: 'query', index, expected: expectedQuery, actual: actualQuery });
+        }
+    }
+    const expectedUpdates = expected.updates ?? [];
+    const actualUpdates = actual.updates ?? [];
+    const maxUpdates = Math.max(expectedUpdates.length, actualUpdates.length);
+    for (let index = 0; index < maxUpdates; index += 1) {
+        const expectedEntry = expectedUpdates[index];
+        const actualEntry = actualUpdates[index];
+        if (!updatesEqual(expectedEntry, actualEntry)) {
+            mismatches.push({ kind: 'update', index, expected: expectedEntry, actual: actualEntry });
+        }
+    }
     return { mismatches };
 });
 export const resolveHistoryLastEventId = (events) => {
@@ -180,6 +221,9 @@ export const cloneDeterminismState = (state) => ({
     randomValues: [...state.randomValues],
     timeValues: [...state.timeValues],
     failureMetadata: state.failureMetadata ? { ...state.failureMetadata } : undefined,
+    signals: state.signals ? state.signals.map((record) => ({ ...record })) : [],
+    queries: state.queries ? state.queries.map((record) => ({ ...record })) : [],
+    updates: state.updates ? state.updates.map((entry) => ({ ...entry })) : undefined,
 });
 const sortHistoryEvents = (events) => events.slice().sort((left, right) => {
     const leftId = resolveEventIdForSort(left);
@@ -340,9 +384,12 @@ const resolveCommandMismatchMetadata = (expectedEntry, actualEntry) => {
         eventType,
     };
 };
-const reconstructDeterminismState = (events, intake, failureMetadata) => Effect.gen(function* () {
+const reconstructDeterminismState = (events, intake, failureMetadata, precomputedUpdates, replayUpdateInvocations = []) => Effect.gen(function* () {
     let sequence = 0;
     const commandHistory = [];
+    const signalRecords = [];
+    const queryRecords = [];
+    const updates = precomputedUpdates ?? collectWorkflowUpdateEntries(events);
     for (const event of events) {
         switch (event.eventType) {
             case EventType.ACTIVITY_TASK_SCHEDULED: {
@@ -401,6 +448,25 @@ const reconstructDeterminismState = (events, intake, failureMetadata) => Effect.
                 }
                 break;
             }
+            case EventType.WORKFLOW_EXECUTION_SIGNALED: {
+                if (event.attributes?.case !== 'workflowExecutionSignaledEventAttributes') {
+                    break;
+                }
+                const attributes = event.attributes.value;
+                const payloads = yield* decodePayloadArray(intake.dataConverter, attributes.input);
+                const workflowTaskCompletedEventId = 'workflowTaskCompletedEventId' in attributes
+                    ? normalizeEventId(attributes
+                        .workflowTaskCompletedEventId)
+                    : null;
+                signalRecords.push({
+                    signalName: attributes.signalName ?? 'unknown',
+                    payloadHash: stableStringify(payloads),
+                    eventId: normalizeEventId(event.eventId),
+                    workflowTaskCompletedEventId,
+                    identity: attributes.identity ?? null,
+                });
+                break;
+            }
             case EventType.WORKFLOW_EXECUTION_CONTINUED_AS_NEW: {
                 if (event.attributes?.case !== 'workflowExecutionContinuedAsNewEventAttributes') {
                     break;
@@ -419,15 +485,21 @@ const reconstructDeterminismState = (events, intake, failureMetadata) => Effect.
                 break;
         }
     }
+    let determinismState = {
+        commandHistory,
+        randomValues: [],
+        timeValues: [],
+        ...(failureMetadata ? { failureMetadata } : {}),
+        signals: signalRecords,
+        queries: queryRecords,
+        ...(updates.length > 0 ? { updates } : {}),
+    };
+    determinismState = mergePendingQueryRequests(determinismState, intake.queries);
     return {
-        determinismState: {
-            commandHistory,
-            randomValues: [],
-            timeValues: [],
-            ...(failureMetadata ? { failureMetadata } : {}),
-        },
+        determinismState,
         lastEventId: resolveHistoryLastEventId(events),
         hasDeterminismMarker: false,
+        ...(replayUpdateInvocations.length > 0 ? { updates: replayUpdateInvocations } : {}),
     };
 });
 const fromActivityTaskScheduled = (attributes, sequence, intake) => Effect.gen(function* () {
@@ -550,6 +622,190 @@ const fromContinueAsNew = (attributes, sequence, intake) => Effect.gen(function*
     };
     return intent;
 });
+const collectWorkflowUpdateEntries = (events) => {
+    const updates = [];
+    for (const event of events) {
+        if (!event.attributes) {
+            continue;
+        }
+        const historyEventId = normalizeEventId(event.eventId) ?? undefined;
+        switch (event.eventType) {
+            case EventType.WORKFLOW_EXECUTION_UPDATE_ADMITTED: {
+                if (event.attributes.case !== 'workflowExecutionUpdateAdmittedEventAttributes') {
+                    break;
+                }
+                const attrs = event.attributes.value;
+                const updateId = normalizeUpdateId(attrs.request?.meta?.updateId);
+                if (!updateId) {
+                    break;
+                }
+                updates.push({
+                    updateId,
+                    stage: 'admitted',
+                    handlerName: normalizeOptionalNonEmptyString(attrs.request?.input?.name),
+                    identity: normalizeOptionalNonEmptyString(attrs.request?.meta?.identity),
+                    historyEventId,
+                });
+                break;
+            }
+            case EventType.WORKFLOW_EXECUTION_UPDATE_ACCEPTED: {
+                if (event.attributes.case !== 'workflowExecutionUpdateAcceptedEventAttributes') {
+                    break;
+                }
+                const attrs = event.attributes.value;
+                const updateId = normalizeUpdateId(attrs.acceptedRequest?.meta?.updateId);
+                if (!updateId) {
+                    break;
+                }
+                updates.push({
+                    updateId,
+                    stage: 'accepted',
+                    handlerName: normalizeOptionalNonEmptyString(attrs.acceptedRequest?.input?.name),
+                    identity: normalizeOptionalNonEmptyString(attrs.acceptedRequest?.meta?.identity),
+                    messageId: normalizeOptionalNonEmptyString(attrs.acceptedRequestMessageId),
+                    sequencingEventId: normalizeBigintIdentifier(attrs.acceptedRequestSequencingEventId),
+                    historyEventId,
+                });
+                break;
+            }
+            case EventType.WORKFLOW_EXECUTION_UPDATE_REJECTED: {
+                if (event.attributes.case !== 'workflowExecutionUpdateRejectedEventAttributes') {
+                    break;
+                }
+                const attrs = event.attributes.value;
+                const updateId = normalizeUpdateId(attrs.rejectedRequest?.meta?.updateId);
+                if (!updateId) {
+                    break;
+                }
+                updates.push({
+                    updateId,
+                    stage: 'rejected',
+                    handlerName: normalizeOptionalNonEmptyString(attrs.rejectedRequest?.input?.name),
+                    identity: normalizeOptionalNonEmptyString(attrs.rejectedRequest?.meta?.identity),
+                    messageId: normalizeOptionalNonEmptyString(attrs.rejectedRequestMessageId),
+                    sequencingEventId: normalizeBigintIdentifier(attrs.rejectedRequestSequencingEventId),
+                    failureMessage: normalizeOptionalNonEmptyString(attrs.failure?.message),
+                    historyEventId,
+                });
+                break;
+            }
+            case EventType.WORKFLOW_EXECUTION_UPDATE_COMPLETED: {
+                if (event.attributes.case !== 'workflowExecutionUpdateCompletedEventAttributes') {
+                    break;
+                }
+                const attrs = event.attributes.value;
+                const updateId = normalizeUpdateId(attrs.meta?.updateId);
+                if (!updateId) {
+                    break;
+                }
+                updates.push({
+                    updateId,
+                    stage: 'completed',
+                    identity: normalizeOptionalNonEmptyString(attrs.meta?.identity),
+                    acceptedEventId: normalizeBigintIdentifier(attrs.acceptedEventId),
+                    outcome: resolveOutcomeStatus(attrs.outcome),
+                    historyEventId,
+                });
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return updates;
+};
+const collectWorkflowUpdateInvocations = async (events, dataConverter) => {
+    const invocations = [];
+    for (const event of events) {
+        if (event.eventType === EventType.WORKFLOW_EXECUTION_UPDATE_ACCEPTED) {
+            if (event.attributes.case !== 'workflowExecutionUpdateAcceptedEventAttributes') {
+                continue;
+            }
+            const attrs = event.attributes.value;
+            const invocation = await buildUpdateInvocationFromRequest({
+                request: attrs.acceptedRequest,
+                protocolInstanceId: attrs.protocolInstanceId,
+                requestMessageId: attrs.acceptedRequestMessageId,
+                sequencingEventId: attrs.acceptedRequestSequencingEventId,
+                fallbackEventId: event.eventId,
+                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);
+            }
+            continue;
+        }
+        if (event.eventType === EventType.WORKFLOW_EXECUTION_UPDATE_ADMITTED) {
+            if (event.attributes.case !== 'workflowExecutionUpdateAdmittedEventAttributes') {
+                continue;
+            }
+            const attrs = event.attributes.value;
+            const invocation = await buildUpdateInvocationFromRequest({
+                request: attrs.request,
+                protocolInstanceId: 'history-admitted',
+                requestMessageId: `history-${event.eventId ?? 'update-admitted'}`,
+                sequencingEventId: event.eventId ? BigInt(event.eventId) : undefined,
+                fallbackEventId: event.eventId,
+                dataConverter,
+            });
+            if (invocation) {
+                invocations.push(invocation);
+            }
+        }
+    }
+    return invocations;
+};
+const buildUpdateInvocationFromRequest = async (input) => {
+    const req = input.request;
+    const updateId = normalizeUpdateId(req?.meta?.updateId);
+    const updateName = req?.input?.name?.trim();
+    if (!updateId || !updateName) {
+        return undefined;
+    }
+    const values = (await decodePayloadsToValues(input.dataConverter, req?.input?.args?.payloads ?? []))?.map((value) => value) ?? [];
+    const payload = normalizeUpdateInvocationPayload(values);
+    const sequencing = input.sequencingEventId !== undefined
+        ? input.sequencingEventId.toString()
+        : input.fallbackEventId !== undefined && input.fallbackEventId !== null
+            ? String(input.fallbackEventId)
+            : undefined;
+    return {
+        protocolInstanceId: input.protocolInstanceId ?? 'history-replay',
+        requestMessageId: input.requestMessageId ?? updateId,
+        updateId,
+        name: updateName,
+        payload,
+        identity: req?.meta?.identity,
+        sequencingEventId: sequencing,
+    };
+};
+const normalizeUpdateInvocationPayload = (values) => {
+    if (!values || values.length === 0) {
+        return undefined;
+    }
+    if (values.length === 1) {
+        return values[0];
+    }
+    return values;
+};
 const decodePayloadArray = (converter, payloads) => Effect.tryPromise(async () => await decodePayloadsToValues(converter, payloads?.payloads ?? []));
 const convertRetryPolicy = (policy) => {
     if (!policy) {
@@ -575,6 +831,45 @@ const convertRetryPolicy = (policy) => {
         ...(nonRetryable !== undefined ? { nonRetryableErrorTypes: nonRetryable } : {}),
     };
 };
+const normalizeUpdateId = (value) => {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+};
+const normalizeOptionalNonEmptyString = (value) => {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+};
+const normalizeBigintIdentifier = (value) => {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (typeof value === 'string') {
+        return value.length > 0 ? value : undefined;
+    }
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value.toString();
+    }
+    if (typeof value === 'bigint') {
+        return value.toString();
+    }
+    return undefined;
+};
+const resolveOutcomeStatus = (outcome) => {
+    const caseName = outcome?.value?.case;
+    if (caseName === 'success') {
+        return 'success';
+    }
+    if (caseName === 'failure') {
+        return 'failure';
+    }
+    return undefined;
+};
 const sanitizeDeterminismMarkerEnvelope = (input) => {
     const schemaVersion = input.schemaVersion;
     if (schemaVersion !== DETERMINISM_MARKER_SCHEMA_VERSION) {
@@ -611,6 +906,9 @@ const sanitizeDeterminismState = (value) => {
     const commandHistoryRaw = value.commandHistory;
     const randomValuesRaw = value.randomValues;
     const timeValuesRaw = value.timeValues;
+    const signalsRaw = Array.isArray(value.signals) ? value.signals : [];
+    const queriesRaw = Array.isArray(value.queries) ? value.queries : [];
+    const updatesRaw = value.updates;
     if (!Array.isArray(commandHistoryRaw) || !Array.isArray(randomValuesRaw) || !Array.isArray(timeValuesRaw)) {
         throw new Error('Determinism marker contained invalid determinism state shape');
     }
@@ -627,11 +925,17 @@ 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 failureMetadata = sanitizeFailureMetadata(value.failureMetadata);
+    const signals = signalsRaw.map((record, index) => sanitizeSignalRecord(record, index));
+    const queries = queriesRaw.map((record, index) => sanitizeQueryRecord(record, index));
+    const updates = sanitizeDeterminismUpdates(updatesRaw);
     return {
         commandHistory,
         randomValues,
         timeValues,
         ...(failureMetadata ? { failureMetadata } : {}),
+        signals,
+        queries,
+        ...(updates ? { updates } : {}),
     };
 };
 const sanitizeCommandMetadata = (value, index) => {
@@ -678,6 +982,81 @@ const sanitizeFailureMetadata = (value) => {
         ...(retryState !== undefined ? { retryState } : {}),
     };
 };
+const sanitizeDeterminismUpdates = (value) => {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (!Array.isArray(value)) {
+        throw new Error('Determinism marker contained invalid updates list');
+    }
+    return value.map((entry, index) => {
+        if (!isRecord(entry)) {
+            throw new Error(`Determinism marker update entry ${index} is invalid`);
+        }
+        const updateId = coerceString(entry.updateId, `determinism.updates[${index}].updateId`);
+        const stage = sanitizeUpdateStage(entry.stage, index);
+        const handlerName = coerceOptionalTrimmedString(entry.handlerName, `determinism.updates[${index}].handlerName`);
+        const identity = coerceOptionalTrimmedString(entry.identity, `determinism.updates[${index}].identity`);
+        const sequencingEventId = coerceOptionalTrimmedString(entry.sequencingEventId, `determinism.updates[${index}].sequencingEventId`);
+        const messageId = coerceOptionalTrimmedString(entry.messageId, `determinism.updates[${index}].messageId`);
+        const acceptedEventId = coerceOptionalTrimmedString(entry.acceptedEventId, `determinism.updates[${index}].acceptedEventId`);
+        const outcome = sanitizeUpdateOutcome(entry.outcome, index);
+        const failureMessage = coerceOptionalTrimmedString(entry.failureMessage, `determinism.updates[${index}].failureMessage`);
+        const historyEventId = coerceOptionalTrimmedString(entry.historyEventId, `determinism.updates[${index}].historyEventId`);
+        return {
+            updateId,
+            stage,
+            ...(handlerName ? { handlerName } : {}),
+            ...(identity ? { identity } : {}),
+            ...(sequencingEventId ? { sequencingEventId } : {}),
+            ...(messageId ? { messageId } : {}),
+            ...(acceptedEventId ? { acceptedEventId } : {}),
+            ...(outcome ? { outcome } : {}),
+            ...(failureMessage ? { failureMessage } : {}),
+            ...(historyEventId ? { historyEventId } : {}),
+        };
+    });
+};
+const sanitizeSignalRecord = (value, index) => {
+    if (!isRecord(value)) {
+        throw new Error(`Determinism marker contained invalid signal entry at index ${index}`);
+    }
+    const signalName = coerceString(value.signalName, `determinism.signals[${index}].signalName`);
+    const payloadHash = coerceString(value.payloadHash, `determinism.signals[${index}].payloadHash`);
+    const handlerName = coerceOptionalString(value.handlerName, `determinism.signals[${index}].handlerName`);
+    const eventId = normalizeOptionalEventId(value.eventId, `determinism.signals[${index}].eventId`);
+    const workflowTaskCompletedEventId = normalizeOptionalEventId(value.workflowTaskCompletedEventId, `determinism.signals[${index}].workflowTaskCompletedEventId`);
+    const identity = coerceOptionalString(value.identity, `determinism.signals[${index}].identity`);
+    return {
+        signalName,
+        payloadHash,
+        ...(handlerName ? { handlerName } : {}),
+        ...(eventId ? { eventId } : {}),
+        ...(workflowTaskCompletedEventId ? { workflowTaskCompletedEventId } : {}),
+        ...(identity ? { identity } : {}),
+    };
+};
+const sanitizeQueryRecord = (value, index) => {
+    if (!isRecord(value)) {
+        throw new Error(`Determinism marker contained invalid query entry at index ${index}`);
+    }
+    const queryName = coerceString(value.queryName, `determinism.queries[${index}].queryName`);
+    const requestHash = coerceString(value.requestHash, `determinism.queries[${index}].requestHash`);
+    const handlerName = coerceOptionalString(value.handlerName, `determinism.queries[${index}].handlerName`);
+    const identity = coerceOptionalString(value.identity, `determinism.queries[${index}].identity`);
+    const queryId = coerceOptionalString(value.queryId, `determinism.queries[${index}].queryId`);
+    const resultHash = coerceOptionalString(value.resultHash, `determinism.queries[${index}].resultHash`);
+    const failureHash = coerceOptionalString(value.failureHash, `determinism.queries[${index}].failureHash`);
+    return {
+        queryName,
+        requestHash,
+        ...(handlerName ? { handlerName } : {}),
+        ...(identity ? { identity } : {}),
+        ...(queryId ? { queryId } : {}),
+        ...(resultHash ? { resultHash } : {}),
+        ...(failureHash ? { failureHash } : {}),
+    };
+};
 const sanitizeRecordedAt = (value) => {
     if (typeof value === 'string' && value.length > 0) {
         return value;
@@ -717,6 +1096,14 @@ const coerceOptionalString = (value, label) => {
     }
     return value.length > 0 ? value : undefined;
 };
+const coerceOptionalTrimmedString = (value, label) => {
+    const raw = coerceOptionalString(value, label);
+    if (raw === undefined) {
+        return undefined;
+    }
+    const trimmed = raw.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+};
 const coerceNumber = (value, label) => {
     if (typeof value === 'number' && Number.isFinite(value)) {
         return value;
@@ -746,6 +1133,21 @@ const normalizeOptionalEventId = (value, label) => {
         throw new Error(`Determinism marker contained invalid ${label}`);
     }
 };
+const sanitizeUpdateStage = (value, index) => {
+    if (value === 'admitted' || value === 'accepted' || value === 'rejected' || value === 'completed') {
+        return value;
+    }
+    throw new Error(`Determinism marker update entry ${index} contained invalid stage`);
+};
+const sanitizeUpdateOutcome = (value, index) => {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    if (value === 'success' || value === 'failure') {
+        return value;
+    }
+    throw new Error(`Determinism marker update entry ${index} contained invalid outcome`);
+};
 const valuesEqual = (expected, actual) => {
     if (expected === undefined && actual === undefined) {
         return true;
@@ -755,5 +1157,48 @@ const valuesEqual = (expected, actual) => {
     }
     return Object.is(expected, actual);
 };
+const updatesEqual = (expected, actual) => {
+    if (!expected && !actual) {
+        return true;
+    }
+    if (!expected || !actual) {
+        return false;
+    }
+    return (expected.updateId === actual.updateId &&
+        expected.stage === actual.stage &&
+        expected.handlerName === actual.handlerName &&
+        expected.identity === actual.identity &&
+        expected.sequencingEventId === actual.sequencingEventId &&
+        expected.messageId === actual.messageId &&
+        expected.outcome === actual.outcome &&
+        expected.failureMessage === actual.failureMessage);
+};
+const recordsMatch = (expected, actual) => {
+    if (expected === undefined && actual === undefined) {
+        return true;
+    }
+    if (expected === undefined || actual === undefined) {
+        return false;
+    }
+    return stableStringify(expected) === stableStringify(actual);
+};
+const mergePendingQueryRequests = (state, requests) => {
+    if (!requests || requests.length === 0) {
+        return state;
+    }
+    const nextQueries = state.queries ? [...state.queries] : [];
+    for (const request of requests) {
+        nextQueries.push({
+            queryName: request.name,
+            requestHash: stableStringify(request.args ?? []),
+            ...(request.metadata?.identity ? { identity: request.metadata.identity } : {}),
+            ...(request.id ? { queryId: request.id } : {}),
+        });
+    }
+    return {
+        ...state,
+        queries: nextQueries,
+    };
+};
 const isRecord = (value) => typeof value === 'object' && value !== null;
 //# sourceMappingURL=replay.js.map