@servicetitan/journey 3.0.1 → 4.1.0

package/src/__tests__/core/persist.test.ts

@@ -0,0 +1,496 @@
+/** @jest-environment jsdom */
+/* eslint-disable @typescript-eslint/naming-convention -- st_journey_id is the deliberate snake_case correlation tag/cookie name */
+import {
+    baseJourneyDef,
+    lastJourney,
+    useJourneyTestRuntime,
+} from '../../__test-utils__/test-runtime';
+import {
+    completeJourney,
+    defineJourney,
+    failJourney,
+    journeyStep,
+    restoreJourney,
+    serializeJourneyState,
+} from '../../core';
+import { moduleRuntime } from '../../core/runtime';
+import { JourneyStepStamp } from '../../core/step-tag';
+
+type SerializedJourneyState = NonNullable<ReturnType<typeof serializeJourneyState>>;
+
+const emitMock = jest.fn();
+const baseDef = {
+    ...baseJourneyDef,
+    name: 'persist-api',
+    timeoutMs: 1_000,
+    expected: ['password', 'mfa', 'client-ready'] as const,
+};
+
+describe('[journey] persist (serialize / restore)', () => {
+    useJourneyTestRuntime(emitMock);
+
+    beforeEach(() => {
+        jest.useFakeTimers();
+    });
+
+    afterEach(() => {
+        jest.useRealTimers();
+    });
+
+    describe('serializeJourneyState', () => {
+        beforeEach(() => {
+            moduleRuntime.startJourney({ ...baseDef, tags: { st_journey_id: 'abc-123' } });
+        });
+
+        const subject = () => {
+            let snapshot: SerializedJourneyState | null = null;
+            return journeyStep(baseDef.name, 'password', step => {
+                step.setAttribute('channel', 'web');
+                snapshot = serializeJourneyState(baseDef.name);
+                return snapshot;
+            }).then(() => snapshot as SerializedJourneyState);
+        };
+
+        test('projects steps to the finish() shape (name/startMs/durationMs/outcome)', async () => {
+            const snapshot = await subject();
+
+            expect(snapshot.steps).toHaveLength(1);
+            const step = snapshot.steps[0];
+            expect(step.name).toBe('password');
+            expect(step.startMs).toBe(0);
+            expect(step.durationMs).toBeGreaterThanOrEqual(0);
+            expect(step.outcome).toBe('good');
+            expect(step.attributes).toEqual({ channel: 'web' });
+        });
+
+        test('carries stJourneyId, startedAtEpoch, verdict, reason, tags', async () => {
+            const snapshot = await subject();
+
+            expect(snapshot.stJourneyId).toBe('abc-123');
+            expect(typeof snapshot.startedAtEpoch).toBe('number');
+            expect(snapshot.verdict).toBe('good');
+            expect(snapshot.reason).toBeNull();
+            expect(snapshot.tags.st_journey_id).toBe('abc-123');
+        });
+
+        test('does not close the journey', async () => {
+            await subject();
+
+            expect(moduleRuntime.getOpenJourney(baseDef.name)).toBeDefined();
+            expect(emitMock).not.toHaveBeenCalled();
+        });
+
+        test('returns null when no journey is open', () => {
+            expect(serializeJourneyState('not-open')).toBeNull();
+        });
+
+        test('strips non-serializable fields (no timer / engine / config / circular journey)', async () => {
+            const snapshot = await subject();
+            const json = JSON.stringify(snapshot);
+
+            expect(json).toContain('"steps"');
+            // The serialized shape is a plain projection — no engine/config/timer keys.
+            expect(snapshot).not.toHaveProperty('timer');
+            expect(snapshot).not.toHaveProperty('config');
+            expect(snapshot).not.toHaveProperty('JOURNEY_ENGINE');
+            expect(snapshot.steps[0]).not.toHaveProperty('journey');
+            expect(snapshot.steps[0]).not.toHaveProperty('attributedRequestKeys');
+            expect(snapshot.steps[0]).not.toHaveProperty('onHttpAborted');
+        });
+
+        test('snapshots a real elapsed duration for in-flight steps (durationMs is 0 until finally)', async () => {
+            moduleRuntime.startJourney({ ...baseDef, tags: { st_journey_id: 'inflight' } });
+            let snapshot: SerializedJourneyState | null = null;
+            await journeyStep(baseDef.name, 'password', () => {
+                /*
+                 * Advance the clock while the step is still open — its durationMs is 0
+                 * until journeyStep's finally block runs, so serialize must compute it.
+                 */
+                jest.advanceTimersByTime(50);
+                snapshot = serializeJourneyState(baseDef.name);
+            });
+            expect(snapshot).not.toBeNull();
+            expect(snapshot!.steps).toHaveLength(1);
+            expect(snapshot!.steps[0].durationMs).toBeGreaterThanOrEqual(50);
+        });
+    });
+
+    describe('restoreJourney', () => {
+        const buildSnapshot = async (
+            overrides: Partial<SerializedJourneyState> = {}
+        ): Promise<SerializedJourneyState> => {
+            moduleRuntime.startJourney({ ...baseDef, tags: { st_journey_id: 'xyz' } });
+            await journeyStep(baseDef.name, 'password', step => {
+                step.setAttribute('channel', 'web');
+            });
+            const snap = serializeJourneyState(baseDef.name) as SerializedJourneyState;
+            // Close the original so the runtime is clean for restore.
+            moduleRuntime.reset({
+                sinks: [emitMock],
+                slowRequests: { defaultMs: 4_000, endpoints: [] },
+            });
+            emitMock.mockClear();
+            return { ...snap, ...overrides };
+        };
+
+        test('rebases startedAt to this page-load timeline', async () => {
+            const snapshot = await buildSnapshot();
+            const before = globalThis.performance.now();
+            const restored = restoreJourney(snapshot, baseDef);
+            const after = globalThis.performance.now();
+
+            expect(restored).toBe(true);
+            const journey = moduleRuntime.getOpenJourney(baseDef.name);
+            expect(journey).toBeDefined();
+            expect(journey!.startedAt).toBeGreaterThanOrEqual(before);
+            expect(journey!.startedAt).toBeLessThanOrEqual(after);
+        });
+
+        test('re-links step.journey to the restored journey', async () => {
+            const snapshot = await buildSnapshot();
+            restoreJourney(snapshot, baseDef);
+
+            const journey = moduleRuntime.getOpenJourney(baseDef.name);
+            expect(journey!.steps).toHaveLength(1);
+            expect(journey!.steps[0].journey).toBe(journey);
+            expect(journey!.steps[0].name).toBe('password');
+            expect(journey!.steps[0].attributes.channel).toBe('web');
+        });
+
+        test('re-arms the countdown with the remaining budget', async () => {
+            /*
+             * Build a snapshot whose startedAtEpoch is 200ms in the past, with a
+             * 1_000ms journey budget → ~800ms remaining.
+             */
+            const snapshot = await buildSnapshot({
+                startedAtEpoch: Date.now() - 200,
+            });
+            restoreJourney(snapshot, { ...baseDef, timeoutMs: 1_000 });
+
+            // Advance past the remaining budget.
+            await jest.advanceTimersByTimeAsync(900);
+
+            expect(emitMock).toHaveBeenCalledTimes(1);
+            expect(lastJourney(emitMock).outcome).toBe('bad');
+            expect(lastJourney(emitMock).reason).toBe('journey-timeout');
+        });
+
+        test('preserves st_journey_id tag across round-trip', async () => {
+            const snapshot = await buildSnapshot();
+            restoreJourney(snapshot, baseDef);
+
+            const journey = moduleRuntime.getOpenJourney(baseDef.name);
+            expect(journey!.tags.st_journey_id).toBe('xyz');
+        });
+
+        test('restores a failed step with reason and httpStatus', async () => {
+            const snapshot = await buildSnapshot({
+                steps: [
+                    {
+                        name: 'password',
+                        startMs: 0,
+                        durationMs: 23,
+                        outcome: 'bad',
+                        reason: 'request-error',
+                        httpStatus: 500,
+                    },
+                ],
+            });
+
+            restoreJourney(snapshot, baseDef);
+
+            const step = moduleRuntime.getOpenJourney(baseDef.name)!.steps[0];
+            expect(step.outcome).toBe('bad');
+            expect(step.reason).toBe('request-error');
+            expect(step.httpStatus).toBe(500);
+        });
+
+        test('falls back to stJourneyId when tags.st_journey_id is absent', async () => {
+            const snapshot = await buildSnapshot({
+                stJourneyId: 'orphan-id',
+                tags: {},
+            });
+
+            restoreJourney(snapshot, baseDef);
+
+            const journey = moduleRuntime.getOpenJourney(baseDef.name);
+            expect(journey!.tags.st_journey_id).toBe('orphan-id');
+        });
+
+        test('returns false and emits bad when budget exhausted in transit (explicit timeout)', async () => {
+            const snapshot = await buildSnapshot({
+                startedAtEpoch: Date.now() - 2_000,
+            });
+            const restored = restoreJourney(snapshot, { ...baseDef, timeoutMs: 1_000 });
+
+            expect(restored).toBe(false);
+            expect(emitMock).toHaveBeenCalledTimes(1);
+            expect(lastJourney(emitMock).outcome).toBe('bad');
+            expect(lastJourney(emitMock).reason).toBe('journey-timeout');
+            expect(moduleRuntime.getOpenJourney(baseDef.name)).toBeUndefined();
+        });
+
+        test('returns false when a journey under that name is already open', async () => {
+            const snapshot = await buildSnapshot();
+            moduleRuntime.startJourney(baseDef);
+            emitMock.mockClear();
+
+            const restored = restoreJourney(snapshot, baseDef);
+
+            expect(restored).toBe(false);
+            expect(emitMock).not.toHaveBeenCalled();
+        });
+
+        test('emits excluded with journey-idle-timeout when idle budget exhausted in transit (non-explicit timeout)', async () => {
+            /*
+             * Idle timeout = timeoutMs omitted → non-explicit, ms = defaultJourneyIdleMs (15m).
+             * The buildSnapshot uses baseDef (timeoutMs: 1_000, explicit) — override the
+             * serialized startedAtEpoch so the restore sees the journey as ~15m old,
+             * and restore with a config that OMITS timeoutMs so the in-transit check
+             * takes the non-explicit (excluded / journey-idle-timeout) branch.
+             */
+            const snapshot = await buildSnapshot({
+                startedAtEpoch: Date.now() - moduleRuntime.getDefaultJourneyIdleMs() - 1_000,
+            });
+            const idleDef = {
+                name: baseDef.name,
+                team: baseDef.team,
+                group: baseDef.group,
+                service: baseDef.service,
+                expected: baseDef.expected,
+            };
+
+            const restored = restoreJourney(snapshot, idleDef);
+
+            expect(restored).toBe(false);
+            expect(emitMock).toHaveBeenCalledTimes(1);
+            expect(lastJourney(emitMock).outcome).toBe('excluded');
+            expect(lastJourney(emitMock).reason).toBe('journey-idle-timeout');
+            expect(moduleRuntime.getOpenJourney(baseDef.name)).toBeUndefined();
+        });
+
+        test('skips the in-transit timeout check when timeoutMs is 0 (countdown disabled)', async () => {
+            /*
+             * timeoutMs: 0 is explicit and disables the countdown — restoreJourney must
+             * register the journey without arming a timer or emitting.
+             */
+            const snapshot = await buildSnapshot({
+                startedAtEpoch: Date.now() - 999_999,
+            });
+
+            const restored = restoreJourney(snapshot, { ...baseDef, timeoutMs: 0 });
+
+            expect(restored).toBe(true);
+            expect(emitMock).not.toHaveBeenCalled();
+            const journey = moduleRuntime.getOpenJourney(baseDef.name);
+            expect(journey).toBeDefined();
+            expect(journey!.timeoutMs).toBe(0);
+            expect(journey!.timeoutExplicit).toBe(true);
+            expect(journey!.timer).toBeNull();
+        });
+
+        test('survives a JSON round-trip (JSON.parse(JSON.stringify(snapshot)))', async () => {
+            const snapshot = await buildSnapshot();
+            const jsonRoundTripped = JSON.parse(JSON.stringify(snapshot)) as SerializedJourneyState;
+
+            const restored = restoreJourney(jsonRoundTripped, baseDef);
+
+            expect(restored).toBe(true);
+            const journey = moduleRuntime.getOpenJourney(baseDef.name);
+            expect(journey).toBeDefined();
+            expect(journey!.tags.st_journey_id).toBe('xyz');
+            expect(journey!.steps).toHaveLength(1);
+            expect(journey!.steps[0].attributes.channel).toBe('web');
+        });
+
+        test('second concurrent restoreJourney with the same snapshot returns false (already open)', async () => {
+            const snapshot = await buildSnapshot();
+
+            const first = restoreJourney(snapshot, baseDef);
+            emitMock.mockClear();
+            const second = restoreJourney(snapshot, baseDef);
+
+            expect(first).toBe(true);
+            expect(second).toBe(false);
+            expect(emitMock).not.toHaveBeenCalled();
+            expect(moduleRuntime.getOpenJourney(baseDef.name)).toBeDefined();
+        });
+
+        test('caller config tags override serialized tags (precedence)', async () => {
+            const snapshot = await buildSnapshot({
+                tags: { st_journey_id: 'xyz', env: 'dev', region: 'us' },
+            });
+
+            restoreJourney(snapshot, {
+                ...baseDef,
+                tags: { st_journey_id: 'xyz', env: 'prod', owner: 'team-a' },
+            });
+
+            const journey = moduleRuntime.getOpenJourney(baseDef.name);
+            expect(journey).toBeDefined();
+            // config tag wins over serialized tag
+            expect(journey!.tags.env).toBe('prod');
+            // config-only tag is added
+            expect(journey!.tags.owner).toBe('team-a');
+            // serialized-only tag is preserved
+            expect(journey!.tags.region).toBe('us');
+            // st_journey_id preserved
+            expect(journey!.tags.st_journey_id).toBe('xyz');
+        });
+
+        test('restores up to MAX_ATTRIBUTE_KEYS (64) step attributes, dropping excess', async () => {
+            const attrs: Record<string, string> = {};
+            for (let i = 0; i < 70; i++) {
+                attrs[`k${i}`] = 'v';
+            }
+            const snapshot = await buildSnapshot({
+                steps: [
+                    {
+                        name: 'password',
+                        startMs: 0,
+                        durationMs: 23,
+                        outcome: 'good',
+                        attributes: attrs,
+                    },
+                ],
+            });
+
+            restoreJourney(snapshot, baseDef);
+
+            const step = moduleRuntime.getOpenJourney(baseDef.name)!.steps[0];
+            // MAX_ATTRIBUTE_KEYS (64), not MAX_TAG_KEYS (32) — matches setSafeAttribute.
+            expect(Object.keys(step.attributes)).toHaveLength(64);
+            expect(step.attributes.k0).toBe('v');
+            expect(step.attributes.k63).toBe('v');
+            expect(step.attributes.k64).toBeUndefined();
+        });
+
+        test('serializeJourneyState returns null after the original journey has completed', async () => {
+            moduleRuntime.startJourney({ ...baseDef, tags: { st_journey_id: 'done' } });
+            await journeyStep(baseDef.name, 'password', () => {});
+            completeJourney(baseDef.name);
+            emitMock.mockClear();
+
+            expect(serializeJourneyState(baseDef.name)).toBeNull();
+        });
+    });
+
+    describe('defineJourney().start() after restore', () => {
+        test('excludes the restored journey and starts fresh (consumer must not call start() after a successful restore)', async () => {
+            moduleRuntime.startJourney({ ...baseDef, tags: { st_journey_id: 'rs-1' } });
+            await journeyStep(baseDef.name, 'password', () => {});
+            const snapshot = serializeJourneyState(baseDef.name) as SerializedJourneyState;
+            moduleRuntime.reset({
+                sinks: [emitMock],
+                slowRequests: { defaultMs: 4_000, endpoints: [] },
+            });
+            emitMock.mockClear();
+
+            const restored = restoreJourney(snapshot, baseDef);
+            expect(restored).toBe(true);
+
+            // defineJourney().start() excludes the open restored journey and starts fresh.
+            defineJourney(baseDef).start({ extra: 'tag' });
+
+            expect(emitMock).toHaveBeenCalledTimes(1);
+            expect(lastJourney(emitMock).outcome).toBe('excluded');
+            const journey = moduleRuntime.getOpenJourney(baseDef.name);
+            expect(journey).toBeDefined();
+            expect(journey!.closed).toBe(false);
+            expect(journey!.steps).toHaveLength(0);
+            expect(journey!.tags.extra).toBe('tag');
+        });
+    });
+
+    describe('round-trip: serialize → restore → add step → complete', () => {
+        test('all steps (original + new) appear in the final emission', async () => {
+            // Page 1: start + password step + serialize.
+            moduleRuntime.startJourney({ ...baseDef, tags: { st_journey_id: 'rt-1' } });
+            await journeyStep(baseDef.name, 'password', step => {
+                step.setAttribute('channel', 'web');
+            });
+            const snapshot = serializeJourneyState(baseDef.name) as SerializedJourneyState;
+            expect(snapshot).not.toBeNull();
+            // Simulate page navigation: reset the runtime.
+            moduleRuntime.reset({
+                sinks: [emitMock],
+                slowRequests: { defaultMs: 4_000, endpoints: [] },
+            });
+            emitMock.mockClear();
+
+            // Page 2: restore + mfa step + complete.
+            const restored = restoreJourney(snapshot, baseDef);
+            expect(restored).toBe(true);
+            await journeyStep(baseDef.name, 'mfa', step => {
+                step.setAttribute('method', 'sms');
+            });
+            completeJourney(baseDef.name);
+
+            expect(emitMock).toHaveBeenCalledTimes(1);
+            const event = lastJourney(emitMock);
+            expect(event.outcome).toBe('good');
+            expect(event.steps).toHaveLength(2);
+            expect(event.steps[0].name).toBe('password');
+            expect(event.steps[0].attributes).toEqual({ channel: 'web' });
+            expect(event.steps[1].name).toBe('mfa');
+            expect(event.steps[1].attributes).toEqual({ method: 'sms' });
+            expect(event.tags.st_journey_id).toBe('rt-1');
+        });
+
+        test('a restored journey can be failed', async () => {
+            moduleRuntime.startJourney({ ...baseDef, tags: { st_journey_id: 'rt-2' } });
+            await journeyStep(baseDef.name, 'password', () => {});
+            const snapshot = serializeJourneyState(baseDef.name) as SerializedJourneyState;
+            moduleRuntime.reset({
+                sinks: [emitMock],
+                slowRequests: { defaultMs: 4_000, endpoints: [] },
+            });
+            emitMock.mockClear();
+
+            const restored = restoreJourney(snapshot, baseDef);
+            expect(restored).toBe(true);
+            failJourney(baseDef.name, 'mfa-rejected');
+
+            expect(emitMock).toHaveBeenCalledTimes(1);
+            expect(lastJourney(emitMock).outcome).toBe('bad');
+            expect(lastJourney(emitMock).reason).toBe('mfa-rejected');
+        });
+
+        test('a restored journey can record a stamped step for HTTP attribution', async () => {
+            moduleRuntime.startJourney({ ...baseDef, tags: { st_journey_id: 'rt-3' } });
+            await journeyStep(baseDef.name, 'password', () => {});
+            const snapshot = serializeJourneyState(baseDef.name) as SerializedJourneyState;
+            moduleRuntime.reset({
+                sinks: [emitMock],
+                slowRequests: { defaultMs: 4_000, endpoints: [] },
+            });
+            emitMock.mockClear();
+
+            restoreJourney(snapshot, baseDef);
+            let stamp: JourneyStepStamp | undefined;
+            await journeyStep(baseDef.name, 'mfa', step => {
+                stamp = step.stamp();
+            });
+
+            expect(stamp).toBeInstanceOf(JourneyStepStamp);
+            // The stamp's step should belong to the restored journey.
+            const journey = moduleRuntime.getOpenJourney(baseDef.name);
+            expect(journey).toBeDefined();
+            expect(journey!.steps[1].name).toBe('mfa');
+            completeJourney(baseDef.name);
+            expect(lastJourney(emitMock).steps).toHaveLength(2);
+        });
+    });
+
+    describe('defineJourney + serializeJourneyState interop', () => {
+        test('a handle-started journey can be serialized', async () => {
+            const handle = defineJourney({ ...baseDef, tags: { st_journey_id: 'h-1' } });
+            handle.start();
+            await journeyStep(baseDef.name, 'password', () => {});
+            const snapshot = serializeJourneyState(baseDef.name);
+            expect(snapshot).not.toBeNull();
+            expect(snapshot!.stJourneyId).toBe('h-1');
+            expect(snapshot!.steps).toHaveLength(1);
+        });
+    });
+});

package/src/__tests__/integrations/axios.test.ts

@@ -1,5 +1,5 @@
 /** @jest-environment jsdom */
-import { useJourneyTestRuntime } from '../../__test-utils__/test-runtime';
+import { baseJourneyDef, useJourneyTestRuntime } from '../../__test-utils__/test-runtime';
 import { completeJourney, journeyStep } from '../../core';
 import { moduleRuntime } from '../../core/runtime';
 import { getSharedPolicies } from '../../global';
@@ -614,3 +614,40 @@ describe('[journey] instrumentAxios', () => {
         expect(emitMock.mock.calls[0][0].journey.outcome).toBe('good');
     });
 });
+
+describe('[journey] Axios response correlation', () => {
+    useJourneyTestRuntime(emitMock);
+    test.each(['plain', 'get'])(
+        'captures %s headers and preserves the rejection identity',
+        async shape => {
+            const axios = createAxiosMock();
+            axios.defaults.baseURL = 'https://go.servicetitan.com';
+            const restore = instrumentAxios(axios);
+            const headers =
+                shape === 'plain'
+                    ? { 'cf-ray': '0123456789abcdef-IAD' }
+                    : { get: jest.fn().mockReturnValue('0123456789abcdef-IAD') };
+            let error: Error;
+            try {
+                await expect(
+                    journeyStep({ ...baseJourneyDef, name: 'axios-ray' }, 'save', async step => {
+                        const config = axios.requestHandlers[0]({
+                            url: '/test',
+                            stamp: step.stamp(),
+                        });
+                        error = Object.assign(new Error('server error'), {
+                            config,
+                            response: { config, status: 500, headers },
+                        });
+                        await axios.responseErrHandlers[0](error);
+                    })
+                ).rejects.toBe(error!);
+                const event = emitMock.mock.calls[0][0].journey;
+                expect(event.reason).toBe('request-error');
+                expect(event.steps[0].requests[0].rayId).toBe('0123456789abcdef-iad');
+            } finally {
+                restore();
+            }
+        }
+    );
+});

package/src/__tests__/integrations/jquery.test.ts

@@ -1,5 +1,5 @@
 /** @jest-environment jsdom */
-import { useJourneyTestRuntime } from '../../__test-utils__/test-runtime';
+import { baseJourneyDef, useJourneyTestRuntime } from '../../__test-utils__/test-runtime';
 import { completeJourney, journeyStep } from '../../core';
 import { moduleRuntime } from '../../core/runtime';
 import { getSharedPolicies } from '../../global';
@@ -537,3 +537,96 @@ describe('[journey] instrumentJquery', () => {
         expect(emitMock.mock.calls[0][0].journey.outcome).toBe('good');
     });
 });
+
+describe('[journey] jQuery early response correlation', () => {
+    useJourneyTestRuntime(emitMock);
+
+    function pendingAjax($: ReturnType<typeof createJqueryMock>, stamp: unknown) {
+        const callbacks: (() => void)[] = [];
+        const xhr = {
+            status: 500,
+            getResponseHeader: jest.fn().mockReturnValue('0123456789abcdef-IAD'),
+            always(callback: () => void) {
+                callbacks.push(callback);
+            },
+        };
+        const settings = { url: 'https://go.servicetitan.com/test', stamp };
+        for (const prefilter of $.__prefilters) {
+            prefilter(settings, settings, xhr);
+        }
+        return { xhr, settings, callbacks };
+    }
+
+    test('captures before a synchronous application failure and does not duplicate at ajaxComplete', async () => {
+        const $ = createJqueryMock();
+        const restore = instrumentJquery($);
+        try {
+            await journeyStep({ ...baseJourneyDef, name: 'jq-early' }, 'save', step => {
+                const { xhr, settings, callbacks } = pendingAjax($, step.stamp());
+                callbacks.forEach(callback => callback());
+                expect(emitMock).not.toHaveBeenCalled();
+                step.failJourney('application-error');
+                for (const complete of $.__completes) {
+                    complete({}, xhr, settings);
+                }
+            });
+            const event = emitMock.mock.calls[0][0].journey;
+            expect(emitMock).toHaveBeenCalledTimes(1);
+            expect(event.reason).toBe('application-error');
+            expect(event.steps[0].requests).toHaveLength(1);
+            expect(event.steps[0].requests[0].rayId).toBe('0123456789abcdef-iad');
+        } finally {
+            restore();
+        }
+    });
+
+    test('keeps scoring after application callbacks, as before', async () => {
+        const $ = createJqueryMock();
+        const restore = instrumentJquery($);
+        try {
+            await journeyStep({ ...baseJourneyDef, name: 'jq-scoring' }, 'save', step => {
+                const { xhr, settings, callbacks } = pendingAjax($, step.stamp());
+                callbacks.forEach(callback => callback());
+                expect(emitMock).not.toHaveBeenCalled();
+                for (const complete of $.__completes) {
+                    complete({}, xhr, settings);
+                }
+            });
+            const event = emitMock.mock.calls[0][0].journey;
+            expect(event.reason).toBe('request-error');
+            expect(event.steps[0].requests).toHaveLength(1);
+        } finally {
+            restore();
+        }
+    });
+
+    test('restore prevents early observers from modifying outstanding requests', async () => {
+        const $ = createJqueryMock();
+        const restore = instrumentJquery($);
+        await journeyStep({ ...baseJourneyDef, name: 'jq-restored' }, 'save', step => {
+            const { callbacks } = pendingAjax($, step.stamp());
+            restore();
+            callbacks.forEach(callback => callback());
+            step.failJourney('application-error');
+        });
+        expect(emitMock.mock.calls[0][0].journey.steps[0].requests).toBeUndefined();
+    });
+
+    test('a throwing header reader cannot stop the application callback', async () => {
+        const $ = createJqueryMock();
+        const restore = instrumentJquery($);
+        try {
+            await journeyStep({ ...baseJourneyDef, name: 'jq-blocked' }, 'save', step => {
+                const { xhr, callbacks } = pendingAjax($, step.stamp());
+                xhr.getResponseHeader.mockImplementation(() => {
+                    throw new Error('blocked');
+                });
+                expect(() => callbacks.forEach(callback => callback())).not.toThrow();
+                step.failJourney('application-error');
+            });
+            expect(emitMock.mock.calls[0][0].journey.steps[0].requests).toBeUndefined();
+        } finally {
+            restore();
+        }
+    });
+});