@servicetitan/journey 2.0.0 → 3.0.0

package/src/__tests__/config.test.ts

@@ -16,15 +16,12 @@ jest.mock('../integrations/jquery', () => ({
     exposeAppJourney: jest.fn(),
 }));
 
-import {
-    configureJourney,
-    getRequestTimeouts,
-    longestEndpointMatch,
-    sortEndpointsByLongestMatch,
-} from '../config';
+import { configureJourney, getSlowRequests } from '../config';
 import { resetJourney } from '../core';
-import { emitJourneyEvent } from '../core/registry';
+import { moduleRuntime } from '../core/runtime';
 import type { JourneyEvent } from '../core/types';
+import { longestEndpointMatch, sortEndpointsByLongestMatch } from '../core/endpoint-policy';
+import { resetSharedPolicies, setJourneyDefaultEnabled } from '../global';
 import { instrumentAxios } from '../integrations/axios';
 import { instrumentFetch } from '../integrations/fetch';
 import {
@@ -32,6 +29,7 @@ import {
     instrumentJquery,
     type WindowWithAppJourney,
 } from '../integrations/jquery';
+import { sendToConsole } from '../sinks/console';
 import { sendToDatadog } from '../sinks/datadog';
 
 const instrumentAxiosMock = jest.mocked(instrumentAxios);
@@ -39,11 +37,18 @@ const instrumentFetchMock = jest.mocked(instrumentFetch);
 const instrumentJqueryMock = jest.mocked(instrumentJquery);
 const exposeAppJourneyMock = jest.mocked(exposeAppJourney);
 
-describe('[journey] configureJourney / getRequestTimeouts', () => {
+describe('[journey] configureJourney / getSlowRequests', () => {
+    beforeEach(() => {
+        setJourneyDefaultEnabled(true);
+    });
+
     afterEach(() => {
+        setJourneyDefaultEnabled(false);
+        localStorage.clear();
+        resetSharedPolicies();
         resetJourney({
-            sinks: [sendToDatadog],
-            requestTimeouts: { defaultMs: 4_000, endpoints: [] },
+            sinks: [sendToDatadog, sendToConsole],
+            slowRequests: { defaultMs: 4_000, endpoints: [] },
         });
         instrumentAxiosMock.mockClear();
         instrumentFetchMock.mockClear();
@@ -52,27 +57,36 @@ describe('[journey] configureJourney / getRequestTimeouts', () => {
     });
 
     test('defaults to 4s with empty endpoints', () => {
-        expect(getRequestTimeouts()).toEqual({ defaultMs: 4_000, endpoints: [] });
+        expect(getSlowRequests()).toEqual({ defaultMs: 4_000, endpoints: [] });
     });
 
     test('overrides the app-wide request timeout tier', () => {
         configureJourney({
-            requestTimeouts: {
+            slowRequests: {
                 defaultMs: 2_000,
-                endpoints: [{ match: '/slow', timeoutMs: 8_000 }],
+                endpoints: [{ match: '/slow', slowRequestMs: 8_000 }],
             },
         });
 
-        expect(getRequestTimeouts()).toEqual({
+        expect(getSlowRequests()).toEqual({
             defaultMs: 2_000,
-            endpoints: [{ match: '/slow', timeoutMs: 8_000 }],
+            endpoints: [{ match: '/slow', slowRequestMs: 8_000 }],
         });
     });
 
-    test('ignores configureJourney when requestTimeouts is omitted', () => {
-        configureJourney({ requestTimeouts: { defaultMs: 1_000, endpoints: [] } });
+    test('ignores configureJourney when slowRequests is omitted', () => {
+        configureJourney({ slowRequests: { defaultMs: 1_000, endpoints: [] } });
         configureJourney({});
-        expect(getRequestTimeouts().defaultMs).toBe(1_000);
+        expect(getSlowRequests().defaultMs).toBe(1_000);
+    });
+
+    test('clamps maxSteps to 1..200', () => {
+        configureJourney({ maxSteps: Infinity });
+        expect(moduleRuntime.getMaxSteps()).toBe(50);
+        configureJourney({ maxSteps: 0 });
+        expect(moduleRuntime.getMaxSteps()).toBe(50);
+        configureJourney({ maxSteps: 500 });
+        expect(moduleRuntime.getMaxSteps()).toBe(200);
     });
 
     describe('with sinks', () => {
@@ -97,7 +111,7 @@ describe('[journey] configureJourney / getRequestTimeouts', () => {
 
         test('replaces the sink list', () => {
             configureJourney({ sinks: [custom] });
-            emitJourneyEvent(payload);
+            moduleRuntime.emit(payload);
 
             expect(custom).toHaveBeenCalledWith(payload);
             expect(sendToDatadog).not.toHaveBeenCalled();
@@ -105,16 +119,30 @@ describe('[journey] configureJourney / getRequestTimeouts', () => {
 
         test('leaves sinks unchanged when sinks is omitted', () => {
             configureJourney({ sinks: [custom] });
-            configureJourney({ requestTimeouts: { defaultMs: 2_000, endpoints: [] } });
-            emitJourneyEvent(payload);
+            configureJourney({ slowRequests: { defaultMs: 2_000, endpoints: [] } });
+            moduleRuntime.emit(payload);
+
+            expect(custom).toHaveBeenCalledWith(payload);
+            expect(sendToDatadog).not.toHaveBeenCalled();
+        });
+
+        test('ignores a later sinks replacement on this runtime', () => {
+            const warn = jest.spyOn(console, 'warn').mockImplementation(() => undefined);
+            configureJourney({ sinks: [custom] });
+            configureJourney({ sinks: [sendToDatadog] });
+            moduleRuntime.emit(payload);
 
             expect(custom).toHaveBeenCalledWith(payload);
             expect(sendToDatadog).not.toHaveBeenCalled();
+            expect(warn).toHaveBeenCalledWith(
+                expect.stringContaining('sinks already set on this runtime')
+            );
+            warn.mockRestore();
         });
 
         test('disables emission when sinks is empty', () => {
             configureJourney({ sinks: [] });
-            emitJourneyEvent(payload);
+            moduleRuntime.emit(payload);
 
             expect(sendToDatadog).not.toHaveBeenCalled();
             expect(custom).not.toHaveBeenCalled();
@@ -128,6 +156,15 @@ describe('[journey] configureJourney / getRequestTimeouts', () => {
         };
         const jquery = { ajaxPrefilter: jest.fn(), bind: jest.fn() } as never;
         const fetchTarget = { fetch: jest.fn() };
+        let warnSpy: jest.SpyInstance;
+
+        beforeEach(() => {
+            warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+        });
+
+        afterEach(() => {
+            warnSpy.mockRestore();
+        });
 
         test('instruments axios when provided', () => {
             configureJourney({ axios: axios as never });
@@ -158,6 +195,38 @@ describe('[journey] configureJourney / getRequestTimeouts', () => {
             expect(instrumentJqueryMock).toHaveBeenCalledWith(jquery);
         });
 
+        test('instruments global $ when jquery is true', () => {
+            const $ = Object.assign(jest.fn(), { ajaxPrefilter: jest.fn() });
+            (globalThis as { $?: unknown }).$ = $;
+
+            try {
+                configureJourney({ jquery: true });
+
+                expect(instrumentJqueryMock).toHaveBeenCalledWith($);
+            } finally {
+                delete (globalThis as { $?: unknown }).$;
+            }
+        });
+
+        test('falls back to global jQuery when jquery is true and $ is absent', () => {
+            const jQuery = Object.assign(jest.fn(), { ajaxPrefilter: jest.fn() });
+            (globalThis as { jQuery?: unknown }).jQuery = jQuery;
+
+            try {
+                configureJourney({ jquery: true });
+
+                expect(instrumentJqueryMock).toHaveBeenCalledWith(jQuery);
+            } finally {
+                delete (globalThis as { jQuery?: unknown }).jQuery;
+            }
+        });
+
+        test('skips jquery wiring when jquery is false', () => {
+            configureJourney({ jquery: false });
+
+            expect(instrumentJqueryMock).not.toHaveBeenCalled();
+        });
+
         test('exposes App.Journey when exposeAppJourney is true', () => {
             configureJourney({ exposeAppJourney: true });
 
@@ -172,21 +241,64 @@ describe('[journey] configureJourney / getRequestTimeouts', () => {
         });
 
         test('skips transport helpers when omitted', () => {
-            configureJourney({ requestTimeouts: { defaultMs: 1_000, endpoints: [] } });
+            configureJourney({ slowRequests: { defaultMs: 1_000, endpoints: [] } });
 
             expect(instrumentAxiosMock).not.toHaveBeenCalled();
             expect(instrumentFetchMock).not.toHaveBeenCalled();
             expect(instrumentJqueryMock).not.toHaveBeenCalled();
             expect(exposeAppJourneyMock).not.toHaveBeenCalled();
         });
+
+        test('never throws on missing config', () => {
+            const warn = jest.spyOn(console, 'warn').mockImplementation(() => {});
+
+            expect(() => configureJourney(null as never)).not.toThrow();
+            expect(() => configureJourney(undefined as never)).not.toThrow();
+            expect(warn).toHaveBeenCalledWith(
+                expect.stringContaining('[journey] configureJourney: skipped — missing')
+            );
+        });
+
+        test('skips when journey is disabled', () => {
+            setJourneyDefaultEnabled(false);
+            const warn = jest.spyOn(console, 'warn').mockImplementation(() => {});
+
+            configureJourney({ axios: axios as never, fetch: true });
+
+            expect(warn).toHaveBeenCalledWith(
+                expect.stringContaining('[journey] configureJourney: skipped — disabled')
+            );
+            expect(instrumentAxiosMock).not.toHaveBeenCalled();
+            expect(instrumentFetchMock).not.toHaveBeenCalled();
+        });
+
+        test('never throws when a transport step fails', () => {
+            const error = jest.spyOn(console, 'error').mockImplementation(() => {});
+            instrumentAxiosMock.mockImplementationOnce(() => {
+                throw new Error('axios boom');
+            });
+
+            expect(() =>
+                configureJourney({
+                    axios: axios as never,
+                    jquery,
+                    exposeAppJourney: true,
+                })
+            ).not.toThrow();
+
+            expect(error).toHaveBeenCalledWith(
+                '[journey] configureJourney failed',
+                expect.any(Error)
+            );
+        });
     });
 });
 
 describe('longestEndpointMatch', () => {
     // Lookup expects longest-match-first (configureJourney / startJourney sort for you).
     const endpoints = [
-        { match: '/api/invoices', timeoutMs: 2_000 },
-        { match: '/api', timeoutMs: 1_000 },
+        { match: '/api/invoices', slowRequestMs: 2_000 },
+        { match: '/api', slowRequestMs: 1_000 },
         { match: '/other', ignore: true },
     ];
 
@@ -196,8 +308,8 @@ describe('longestEndpointMatch', () => {
     });
 
     test('picks the longest matching prefix (first hit when sorted)', () => {
-        expect(longestEndpointMatch(endpoints, '/api/invoices/42')?.timeoutMs).toBe(2_000);
-        expect(longestEndpointMatch(endpoints, '/api/jobs')?.timeoutMs).toBe(1_000);
+        expect(longestEndpointMatch(endpoints, '/api/invoices/42')?.slowRequestMs).toBe(2_000);
+        expect(longestEndpointMatch(endpoints, '/api/jobs')?.slowRequestMs).toBe(1_000);
     });
 
     test('returns undefined when nothing matches', () => {
@@ -205,40 +317,44 @@ describe('longestEndpointMatch', () => {
     });
 
     test('requires a path boundary after the prefix', () => {
-        const user = [{ match: '/api/user', timeoutMs: 1_000 }];
-        expect(longestEndpointMatch(user, '/api/user')?.timeoutMs).toBe(1_000);
-        expect(longestEndpointMatch(user, '/api/user/42')?.timeoutMs).toBe(1_000);
+        const user = [{ match: '/api/user', slowRequestMs: 1_000 }];
+        expect(longestEndpointMatch(user, '/api/user')?.slowRequestMs).toBe(1_000);
+        expect(longestEndpointMatch(user, '/api/user/42')?.slowRequestMs).toBe(1_000);
         expect(longestEndpointMatch(user, '/api/user-preferences')).toBeUndefined();
         expect(longestEndpointMatch(user, '/api/users')).toBeUndefined();
 
-        const trailed = [{ match: '/api/user/', timeoutMs: 2_000 }];
-        expect(longestEndpointMatch(trailed, '/api/user/42')?.timeoutMs).toBe(2_000);
+        const trailed = [{ match: '/api/user/', slowRequestMs: 2_000 }];
+        expect(longestEndpointMatch(trailed, '/api/user/42')?.slowRequestMs).toBe(2_000);
     });
 });
 
 describe('configureJourney endpoint ordering', () => {
+    beforeEach(() => {
+        setJourneyDefaultEnabled(true);
+    });
+
     afterEach(() => {
+        setJourneyDefaultEnabled(false);
+        localStorage.clear();
+        resetSharedPolicies();
         resetJourney({
-            sinks: [sendToDatadog],
-            requestTimeouts: { defaultMs: 4_000, endpoints: [] },
+            sinks: [sendToDatadog, sendToConsole],
+            slowRequests: { defaultMs: 4_000, endpoints: [] },
         });
     });
 
     test('stores endpoints longest-match-first', () => {
         configureJourney({
-            requestTimeouts: {
+            slowRequests: {
                 defaultMs: 4_000,
                 endpoints: [
-                    { match: '/api', timeoutMs: 1_000 },
-                    { match: '/api/invoices', timeoutMs: 2_000 },
+                    { match: '/api', slowRequestMs: 1_000 },
+                    { match: '/api/invoices', slowRequestMs: 2_000 },
                 ],
             },
         });
 
-        expect(getRequestTimeouts().endpoints?.map(e => e.match)).toEqual([
-            '/api/invoices',
-            '/api',
-        ]);
+        expect(getSlowRequests().endpoints?.map(e => e.match)).toEqual(['/api/invoices', '/api']);
     });
 });
 
@@ -248,7 +364,7 @@ describe('[journey] sortEndpointsByLongestMatch', () => {
     });
 
     test('returns a copy for a single endpoint', () => {
-        const only = [{ match: '/api', timeoutMs: 1_000 }];
+        const only = [{ match: '/api', slowRequestMs: 1_000 }];
         const sorted = sortEndpointsByLongestMatch(only);
 
         expect(sorted).toEqual(only);

package/src/__tests__/{ambient.test.ts → core/ambient.test.ts}

@@ -1,27 +1,33 @@
 /** @jest-environment jsdom */
-import { baseJourneyDef, useJourneyTestRuntime } from '../__mocks__/test-runtime';
-import { activeJourneyStep, completeJourney, journeyStep, startJourney } from '../core';
+import { baseJourneyDef, useJourneyTestRuntime } from '../../__test-utils__/test-runtime';
+import {
+    singleInFlightJourneyStep,
+    completeJourney,
+    journeyStep,
+    JourneyStepStamp,
+} from '../../core';
+import { moduleRuntime } from '../../core/runtime';
 
 const emitMock = jest.fn();
 const baseDef = { ...baseJourneyDef, name: 'ambient-a' };
 const otherDef = { ...baseJourneyDef, name: 'ambient-b' };
 
-describe('[journey] activeJourneyStep', () => {
+describe('[journey] singleInFlightJourneyStep', () => {
     useJourneyTestRuntime(emitMock);
 
     describe('around a single step', () => {
         beforeEach(() => {
-            startJourney(baseDef);
+            moduleRuntime.startJourney(baseDef);
         });
 
         test('is set only while the step is running', async () => {
-            expect(activeJourneyStep()).toBeNull();
+            expect(singleInFlightJourneyStep()).toBeNull();
 
             await journeyStep(baseDef.name, 'do-work', () => {
-                expect(activeJourneyStep()).not.toBeNull();
+                expect(singleInFlightJourneyStep()).toBeInstanceOf(JourneyStepStamp);
             });
 
-            expect(activeJourneyStep()).toBeNull();
+            expect(singleInFlightJourneyStep()).toBeNull();
             completeJourney(baseDef.name);
         });
     });
@@ -31,8 +37,8 @@ describe('[journey] activeJourneyStep', () => {
         let stepA: Promise<unknown>;
 
         beforeEach(() => {
-            startJourney(baseDef);
-            startJourney(otherDef);
+            moduleRuntime.startJourney(baseDef);
+            moduleRuntime.startJourney(otherDef);
 
             const gateA = new Promise<void>(r => {
                 releaseA = r;
@@ -49,7 +55,7 @@ describe('[journey] activeJourneyStep', () => {
             completeJourney(otherDef.name);
         });
 
-        const subject = () => journeyStep(otherDef.name, 'book', () => activeJourneyStep());
+        const subject = () => journeyStep(otherDef.name, 'book', () => singleInFlightJourneyStep());
 
         test('returns null', async () => {
             await expect(subject()).resolves.toBeNull();
@@ -59,11 +65,11 @@ describe('[journey] activeJourneyStep', () => {
     describe('when the first-finishing sibling ends first', () => {
         let releaseB!: () => void;
         let stepB: Promise<unknown>;
-        let ambientWhileBAlone: ReturnType<typeof activeJourneyStep> | 'unset';
+        let ambientWhileBAlone: ReturnType<typeof singleInFlightJourneyStep> | 'unset';
 
         beforeEach(() => {
-            startJourney(baseDef);
-            startJourney(otherDef);
+            moduleRuntime.startJourney(baseDef);
+            moduleRuntime.startJourney(otherDef);
             ambientWhileBAlone = 'unset';
 
             const gateB = new Promise<void>(r => {
@@ -71,7 +77,7 @@ describe('[journey] activeJourneyStep', () => {
             });
             stepB = journeyStep(otherDef.name, 'book', async () => {
                 await gateB;
-                ambientWhileBAlone = activeJourneyStep();
+                ambientWhileBAlone = singleInFlightJourneyStep();
             });
         });
 
@@ -84,7 +90,7 @@ describe('[journey] activeJourneyStep', () => {
 
         test('keeps ambient on the remaining step', async () => {
             await journeyStep(baseDef.name, 'load', () => {
-                expect(activeJourneyStep()).toBeNull();
+                expect(singleInFlightJourneyStep()).toBeNull();
             });
 
             releaseB();
@@ -95,7 +101,8 @@ describe('[journey] activeJourneyStep', () => {
             if (ambientWhileBAlone === 'unset' || ambientWhileBAlone == null) {
                 throw new Error('expected ambient step');
             }
-            expect(ambientWhileBAlone.name).toBe('book');
+            expect(ambientWhileBAlone).toBeInstanceOf(JourneyStepStamp);
+            expect(ambientWhileBAlone.step.name).toBe('book');
         });
     });
 });

package/src/__tests__/{registry.test.ts → core/api.test.ts}

@@ -1,26 +1,29 @@
 /** @jest-environment jsdom */
-import { baseJourneyDef, lastJourney, useJourneyTestRuntime } from '../__mocks__/test-runtime';
+import {
+    baseJourneyDef,
+    lastJourney,
+    useJourneyTestRuntime,
+} from '../../__test-utils__/test-runtime';
 import {
     completeJourney,
     excludeJourney,
     failJourney,
-    firstOpenJourney,
     journeyStep,
     setJourneyTags,
-    startJourney,
-} from '../core';
+} from '../../core';
+import { moduleRuntime } from '../../core/runtime';
 
 const emitMock = jest.fn();
-const baseDef = { ...baseJourneyDef, name: 'registry-api' };
-const otherDef = { ...baseJourneyDef, name: 'registry-other' };
+const baseDef = { ...baseJourneyDef, name: 'api-lifecycle' };
+const otherDef = { ...baseJourneyDef, name: 'api-other' };
 
-describe('[journey] registry', () => {
+describe('[journey] api', () => {
     useJourneyTestRuntime(emitMock);
 
-    describe('firstOpenJourney', () => {
+    describe('firstOpenJourneyName', () => {
         const names = [baseDef.name, otherDef.name];
 
-        const subject = () => firstOpenJourney(names);
+        const subject = () => moduleRuntime.firstOpenJourneyName(names);
 
         describe('when none are open', () => {
             test('returns null', () => {
@@ -30,7 +33,7 @@ describe('[journey] registry', () => {
 
         describe('when only the second name is open', () => {
             beforeEach(() => {
-                startJourney(otherDef);
+                moduleRuntime.startJourney(otherDef);
             });
 
             test('returns that name', () => {
@@ -40,13 +43,15 @@ describe('[journey] registry', () => {
 
         describe('when both are open', () => {
             beforeEach(() => {
-                startJourney(otherDef);
-                startJourney(baseDef);
+                moduleRuntime.startJourney(otherDef);
+                moduleRuntime.startJourney(baseDef);
             });
 
             test('returns the first match in order', () => {
                 expect(subject()).toBe(baseDef.name);
-                expect(firstOpenJourney([otherDef.name, baseDef.name])).toBe(otherDef.name);
+                expect(moduleRuntime.firstOpenJourneyName([otherDef.name, baseDef.name])).toBe(
+                    otherDef.name
+                );
             });
         });
     });
@@ -54,7 +59,7 @@ describe('[journey] registry', () => {
     describe('completeJourney', () => {
         describe('with tags', () => {
             beforeEach(() => {
-                startJourney(baseDef);
+                moduleRuntime.startJourney(baseDef);
             });
 
             const subject = () => completeJourney(baseDef.name, { 'lead.id': 7 });
@@ -78,9 +83,9 @@ describe('[journey] registry', () => {
 
         describe('when already closed', () => {
             beforeEach(async () => {
-                startJourney(baseDef);
+                moduleRuntime.startJourney(baseDef);
                 await journeyStep(baseDef.name, 'do-work', step => {
-                    step.complete();
+                    step.completeJourney();
                 });
             });
 
@@ -95,9 +100,9 @@ describe('[journey] registry', () => {
 
         describe('after a fail', () => {
             beforeEach(async () => {
-                startJourney(baseDef);
+                moduleRuntime.startJourney(baseDef);
                 await journeyStep(baseDef.name, 'do-work', step => {
-                    step.fail('validation');
+                    step.failJourney('validation');
                 });
             });
 
@@ -115,10 +120,10 @@ describe('[journey] registry', () => {
     describe('startJourney', () => {
         describe('when restarting the same name', () => {
             beforeEach(() => {
-                startJourney(baseDef);
+                moduleRuntime.startJourney(baseDef);
             });
 
-            const subject = () => startJourney(baseDef);
+            const subject = () => moduleRuntime.startJourney(baseDef);
 
             test('excludes the prior open journey', () => {
                 subject();
@@ -129,13 +134,13 @@ describe('[journey] registry', () => {
 
         describe('when restarting after a bad close', () => {
             beforeEach(async () => {
-                startJourney(baseDef);
+                moduleRuntime.startJourney(baseDef);
                 await journeyStep(baseDef.name, 'do-work', step => {
-                    step.fail('validation');
+                    step.failJourney('validation');
                 });
             });
 
-            const subject = () => startJourney(baseDef);
+            const subject = () => moduleRuntime.startJourney(baseDef);
 
             test('opens fresh without a second exclude', () => {
                 subject();
@@ -148,7 +153,7 @@ describe('[journey] registry', () => {
 
         describe('with static def tags', () => {
             const subject = () => {
-                startJourney({ ...baseDef, tags: { plan: 'pro' } });
+                moduleRuntime.startJourney({ ...baseDef, tags: { plan: 'pro' } });
                 completeJourney(baseDef.name, { 'job.id': 5 });
             };
 
@@ -162,7 +167,7 @@ describe('[journey] registry', () => {
 
     describe('failJourney', () => {
         beforeEach(() => {
-            startJourney(baseDef);
+            moduleRuntime.startJourney(baseDef);
         });
 
         const subject = () => failJourney(baseDef.name, 'manual-bad');
@@ -188,7 +193,7 @@ describe('[journey] registry', () => {
     describe('excludeJourney', () => {
         describe('with a clean journey', () => {
             beforeEach(() => {
-                startJourney(otherDef);
+                moduleRuntime.startJourney(otherDef);
             });
 
             const subject = () => excludeJourney(otherDef.name);
@@ -202,9 +207,9 @@ describe('[journey] registry', () => {
 
         describe('after a breach', () => {
             beforeEach(async () => {
-                startJourney(baseDef);
+                moduleRuntime.startJourney(baseDef);
                 await journeyStep(baseDef.name, 'do-work', step => {
-                    step.fail('validation');
+                    step.failJourney('validation');
                 });
                 emitMock.mockClear();
             });
@@ -221,7 +226,7 @@ describe('[journey] registry', () => {
         describe('when past the journey budget', () => {
             beforeEach(() => {
                 jest.spyOn(globalThis.performance, 'now').mockReturnValue(1_000);
-                startJourney({ ...baseDef, timeoutMs: 50 });
+                moduleRuntime.startJourney({ ...baseDef, timeoutMs: 50 });
                 (globalThis.performance.now as jest.Mock).mockReturnValue(1_100);
             });
 
@@ -251,7 +256,7 @@ describe('[journey] registry', () => {
 
         describe('with a closed journey', () => {
             beforeEach(() => {
-                startJourney(baseDef);
+                moduleRuntime.startJourney(baseDef);
                 completeJourney(baseDef.name);
             });