@servicetitan/journey 2.0.0 → 3.0.0

package/src/__tests__/{define-journey.test.ts → core/define-journey.test.ts}

@@ -1,6 +1,7 @@
 /** @jest-environment jsdom */
-import { lastJourney, useJourneyTestRuntime } from '../__mocks__/test-runtime';
-import { defineJourney, journeyStep, startJourney } from '../core';
+import { lastJourney, useJourneyTestRuntime } from '../../__test-utils__/test-runtime';
+import { defineJourney, journeyStep } from '../../core';
+import { moduleRuntime } from '../../core/runtime';
 
 const emitMock = jest.fn();
 
@@ -25,7 +26,7 @@ describe('[journey] defineJourney', () => {
         const subject = () =>
             journey.step('do-work', step => {
                 step.setAttribute('x', 1);
-                step.complete({ 'payment.id': 42 });
+                step.completeJourney({ 'payment.id': 42 });
             });
 
         test('opens, records the step, and completes good', async () => {
@@ -40,7 +41,7 @@ describe('[journey] defineJourney', () => {
 
         test('mountStep also opens the journey', async () => {
             await journey.mountStep('boot', step => {
-                step.complete();
+                step.completeJourney();
             });
 
             expect(emitMock).toHaveBeenCalledTimes(1);
@@ -51,12 +52,12 @@ describe('[journey] defineJourney', () => {
 
     describe('when a JourneyScope already opened the journey', () => {
         beforeEach(() => {
-            startJourney(base);
+            moduleRuntime.startJourney(base);
         });
 
         const subject = () =>
             journey.step('do-work', step => {
-                step.complete();
+                step.completeJourney();
             });
 
         test('does not restart the open journey', async () => {
@@ -75,7 +76,7 @@ describe('[journey] defineJourney', () => {
 
         const subject = () =>
             journeyStep(journey, 'via-free', step => {
-                step.complete();
+                step.completeJourney();
             });
 
         test('resolves the handle name', async () => {
@@ -147,12 +148,12 @@ describe('[journey] defineJourney', () => {
 
     describe('when mountStep runs under an already-open journey', () => {
         beforeEach(() => {
-            startJourney(base);
+            moduleRuntime.startJourney(base);
         });
 
         const subject = () =>
             journey.mountStep('boot', step => {
-                step.complete();
+                step.completeJourney();
             });
 
         test('does not restart the open journey', async () => {
@@ -165,12 +166,29 @@ describe('[journey] defineJourney', () => {
         });
     });
 
-    describe('when copying def fields onto the handle', () => {
-        test('exposes the journey config properties', () => {
-            expect(journey.name).toBe(base.name);
-            expect(journey.team).toBe(base.team);
-            expect(journey.group).toBe(base.group);
-            expect(journey.service).toBe(base.service);
+    describe('when keeping the original config on the handle', () => {
+        test('exposes the same config object', () => {
+            expect(journey.config).toBe(base);
+            expect(journey.config.name).toBe(base.name);
+            expect(journey.config.name).toBe(base.name);
+            expect(journey.config.team).toBe(base.team);
+            expect(journey.config.group).toBe(base.group);
+            expect(journey.config.service).toBe(base.service);
+        });
+    });
+
+    describe('when stepping via free journeyStep with a handle and nothing open', () => {
+        const subject = () =>
+            journeyStep(journey, 'via-handle', step => {
+                step.completeJourney();
+            });
+
+        test('auto-starts from the handle config', async () => {
+            await subject();
+
+            expect(emitMock).toHaveBeenCalledTimes(1);
+            expect(lastJourney(emitMock).outcome).toBe('good');
+            expect(lastJourney(emitMock).steps[0].name).toBe('via-handle');
         });
     });
 });

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

@@ -1,21 +1,25 @@
 /** @jest-environment jsdom */
-import { baseJourneyDef, lastJourney, useJourneyTestRuntime } from '../__mocks__/test-runtime';
-import { configureJourney } from '../config';
+import {
+    baseJourneyDef,
+    lastJourney,
+    useJourneyTestRuntime,
+} from '../../__test-utils__/test-runtime';
+import { configureJourney } from '../../config';
 import {
     completeJourney,
     journeyStep,
     reportBackendRequest,
-    resolveJourneyStep,
-    startJourney,
     type JourneyDef,
-    type JourneyStepRef,
-} from '../core';
+    type JourneyStepStamp,
+} from '../../core';
+import type { StepRecord } from '../../core/types';
+import { moduleRuntime } from '../../core/runtime';
 
 const emitMock = jest.fn();
 const baseDef = { ...baseJourneyDef, name: 'requests-journey' };
 
 describe('[journey] reportBackendRequest', () => {
-    let stepRef: JourneyStepRef | undefined;
+    let stepRef: StepRecord | undefined;
     let status: number | undefined;
     let durationMs: number;
     let key: string;
@@ -32,12 +36,12 @@ describe('[journey] reportBackendRequest', () => {
     const subject = () => reportBackendRequest(stepRef, status, durationMs, key);
 
     async function withOpenStep(
-        run: (ref: JourneyStepRef) => void | Promise<void>,
-        def: JourneyDef = { ...baseDef, requestTimeoutMs: 5_000 }
+        run: (ref: StepRecord) => void | Promise<void>,
+        def: JourneyDef = { ...baseDef, slowRequestMs: 5_000 }
     ) {
-        startJourney(def);
+        moduleRuntime.startJourney(def);
         await journeyStep(baseDef.name, 'do-work', async step => {
-            stepRef = resolveJourneyStep((step.tag() as { journeyStep: unknown }).journeyStep);
+            stepRef = (step.stamp() as JourneyStepStamp).step;
             await run(stepRef!);
         });
     }
@@ -96,7 +100,7 @@ describe('[journey] reportBackendRequest', () => {
                 () => {
                     subject();
                 },
-                { ...baseDef, requestTimeoutMs: 50 }
+                { ...baseDef, slowRequestMs: 50 }
             );
 
             expect(lastJourney(emitMock).reason).toBe('request-latency');
@@ -156,7 +160,7 @@ describe('[journey] reportBackendRequest', () => {
                 },
                 {
                     ...baseDef,
-                    requestTimeoutMs: 5_000,
+                    slowRequestMs: 5_000,
                     endpoints: [{ match: '/flaky', ignore: true }],
                 }
             );
@@ -166,28 +170,29 @@ describe('[journey] reportBackendRequest', () => {
         });
     });
 
-    describe('when a journey endpoint timeoutMs is 0', () => {
-        test('falls through to the journey requestTimeoutMs', async () => {
-            startJourney({
+    describe('when a journey endpoint slowRequestMs is 0', () => {
+        test('never scores latency for that prefix', async () => {
+            moduleRuntime.startJourney({
                 ...baseDef,
-                requestTimeoutMs: 30,
-                endpoints: [{ match: '/special', timeoutMs: 0 }],
+                slowRequestMs: 30,
+                endpoints: [{ match: '/special', slowRequestMs: 0 }],
             });
 
             await journeyStep(baseDef.name, 'do-work', step => {
-                stepRef = resolveJourneyStep((step.tag() as { journeyStep: unknown }).journeyStep);
+                stepRef = (step.stamp() as JourneyStepStamp).step;
                 status = 200;
                 durationMs = 100;
                 key = '/special/path';
                 subject();
             });
+            completeJourney(baseDef.name);
 
-            expect(lastJourney(emitMock).reason).toBe('request-latency');
+            expect(lastJourney(emitMock).outcome).toBe('good');
         });
     });
 
     describe('when journey endpoint timeoutMs is set', () => {
-        test('wins over the journey requestTimeoutMs', async () => {
+        test('wins over the journey slowRequestMs', async () => {
             await withOpenStep(
                 () => {
                     status = 200;
@@ -197,8 +202,8 @@ describe('[journey] reportBackendRequest', () => {
                 },
                 {
                     ...baseDef,
-                    requestTimeoutMs: 5_000,
-                    endpoints: [{ match: '/special', timeoutMs: 20 }],
+                    slowRequestMs: 5_000,
+                    endpoints: [{ match: '/special', slowRequestMs: 20 }],
                 }
             );
 
@@ -209,7 +214,7 @@ describe('[journey] reportBackendRequest', () => {
     describe('when the journey endpoint ignore overrides the app-wide policy', () => {
         beforeEach(() => {
             configureJourney({
-                requestTimeouts: {
+                slowRequests: {
                     defaultMs: 4_000,
                     endpoints: [{ match: '/flaky', ignore: true }],
                 },
@@ -225,7 +230,7 @@ describe('[journey] reportBackendRequest', () => {
                 },
                 {
                     ...baseDef,
-                    requestTimeoutMs: 5_000,
+                    slowRequestMs: 5_000,
                     endpoints: [{ match: '/flaky', ignore: false }],
                 }
             );
@@ -237,11 +242,11 @@ describe('[journey] reportBackendRequest', () => {
     describe('when only app-wide endpoint policies apply', () => {
         beforeEach(() => {
             configureJourney({
-                requestTimeouts: {
+                slowRequests: {
                     defaultMs: 4_000,
                     endpoints: [
                         { match: '/ignored', ignore: true },
-                        { match: '/tight', timeoutMs: 30 },
+                        { match: '/tight', slowRequestMs: 30 },
                     ],
                 },
             });
@@ -270,41 +275,42 @@ describe('[journey] reportBackendRequest', () => {
         });
     });
 
-    describe('when app endpoint timeoutMs is 0', () => {
+    describe('when app endpoint slowRequestMs is 0', () => {
         beforeEach(() => {
             configureJourney({
-                requestTimeouts: {
+                slowRequests: {
                     defaultMs: 40,
-                    endpoints: [{ match: '/loose', timeoutMs: 0 }],
+                    endpoints: [{ match: '/loose', slowRequestMs: 0 }],
                 },
             });
         });
 
-        test('falls through to defaultMs', async () => {
-            startJourney(baseDef);
+        test('never scores latency for that prefix', async () => {
+            moduleRuntime.startJourney(baseDef);
 
             await journeyStep(baseDef.name, 'do-work', step => {
-                stepRef = resolveJourneyStep((step.tag() as { journeyStep: unknown }).journeyStep);
+                stepRef = (step.stamp() as JourneyStepStamp).step;
                 status = 200;
                 durationMs = 100;
                 key = '/loose/x';
                 subject();
             });
+            completeJourney(baseDef.name);
 
-            expect(lastJourney(emitMock).reason).toBe('request-latency');
+            expect(lastJourney(emitMock).outcome).toBe('good');
         });
     });
 
-    describe('when the journey has no requestTimeoutMs', () => {
+    describe('when the journey has no slowRequestMs', () => {
         beforeEach(() => {
-            configureJourney({ requestTimeouts: { defaultMs: 40, endpoints: [] } });
+            configureJourney({ slowRequests: { defaultMs: 40, endpoints: [] } });
         });
 
         test('uses the app defaultMs', async () => {
-            startJourney(baseDef);
+            moduleRuntime.startJourney(baseDef);
 
             await journeyStep(baseDef.name, 'do-work', step => {
-                stepRef = resolveJourneyStep((step.tag() as { journeyStep: unknown }).journeyStep);
+                stepRef = (step.stamp() as JourneyStepStamp).step;
                 status = 200;
                 durationMs = 100;
                 key = '/any';
@@ -316,7 +322,7 @@ describe('[journey] reportBackendRequest', () => {
     });
 
     describe('against a closed journey step ref', () => {
-        let closedRef: JourneyStepRef | undefined;
+        let closedRef: StepRecord | undefined;
 
         beforeEach(async () => {
             await withOpenStep(ref => {
@@ -334,4 +340,20 @@ describe('[journey] reportBackendRequest', () => {
             expect(emitMock).not.toHaveBeenCalled();
         });
     });
+
+    describe('when many distinct keys are attributed', () => {
+        test('stops recording after 50 keys', async () => {
+            await withOpenStep(ref => {
+                for (let i = 0; i < 55; i += 1) {
+                    reportBackendRequest(ref, 200, 1, `/api/${i}`);
+                }
+                expect(ref.attributedRequestKeys).toHaveLength(50);
+                expect(
+                    moduleRuntime.getDebugSnapshot().openJourneys[0].steps[0].attributedRequestKeys
+                ).toHaveLength(50);
+            });
+            completeJourney(baseDef.name);
+            expect(lastJourney(emitMock).outcome).toBe('good');
+        });
+    });
 });

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

@@ -1,18 +1,19 @@
 /** @jest-environment jsdom */
-import { lastJourney, useJourneyTestRuntime } from '../__mocks__/test-runtime';
-import { configureJourney, getRequestTimeouts } from '../config';
+import { lastJourney, useJourneyTestRuntime } from '../../__test-utils__/test-runtime';
+import { configureJourney, getSlowRequests } from '../../config';
 import {
-    activeJourneyStep,
     completeJourney,
-    createJourneyRuntime,
     defineJourney,
     journeyStep,
     resetJourney,
-    startJourney,
-} from '../core';
-import { sendToDatadog } from '../sinks/datadog';
-
-jest.mock('../sinks/datadog', () => ({
+    singleInFlightJourneyStep,
+} from '../../core';
+import { createJourneyRuntime, moduleRuntime } from '../../core/runtime';
+import { registerJourneyRuntime, setJourneyDefaultEnabled } from '../../global';
+import { sendToConsole } from '../../sinks/console';
+import { sendToDatadog } from '../../sinks/datadog';
+
+jest.mock('../../sinks/datadog', () => ({
     sendToDatadog: jest.fn(),
 }));
 
@@ -31,7 +32,7 @@ describe('[journey] resetJourney', () => {
 
     describe('when a journey is open', () => {
         beforeEach(() => {
-            startJourney(def);
+            moduleRuntime.startJourney(def);
         });
 
         const subject = () => resetJourney({ sinks: [emitMock] });
@@ -52,29 +53,31 @@ describe('[journey] resetJourney', () => {
 
     describe('when request timeouts were customized', () => {
         beforeEach(() => {
-            configureJourney({ requestTimeouts: { defaultMs: 100, endpoints: [] } });
+            configureJourney({ slowRequests: { defaultMs: 100, endpoints: [] } });
         });
 
         const subject = () => resetJourney({ sinks: [emitMock] });
 
-        test('restores the 4s default', () => {
+        test('clears this runtime overlay and inherits shared policies', () => {
             subject();
 
-            expect(getRequestTimeouts().defaultMs).toBe(4_000);
+            expect(moduleRuntime.getDebugSnapshot().policyOverlay.slowRequests).toBe(false);
+            expect(moduleRuntime.getSlowRequests().defaultMs).toBe(100);
+            expect(getSlowRequests().defaultMs).toBe(100);
         });
     });
 
-    describe('when reset passes custom requestTimeouts', () => {
+    describe('when reset passes custom slowRequests', () => {
         const subject = () =>
             resetJourney({
                 sinks: [emitMock],
-                requestTimeouts: { defaultMs: 250, endpoints: [] },
+                slowRequests: { defaultMs: 250, endpoints: [] },
             });
 
-        test('applies those timeouts', () => {
+        test('applies those timeouts on the module engine', () => {
             subject();
 
-            expect(getRequestTimeouts().defaultMs).toBe(250);
+            expect(moduleRuntime.getSlowRequests().defaultMs).toBe(250);
         });
     });
 
@@ -82,7 +85,7 @@ describe('[journey] resetJourney', () => {
         beforeEach(() => {
             resetJourney({ sinks: [emitMock] });
             emitMock.mockClear();
-            startJourney(def);
+            moduleRuntime.startJourney(def);
             completeJourney(def.name);
             emitMock.mockClear();
         });
@@ -91,7 +94,7 @@ describe('[journey] resetJourney', () => {
 
         test('leaves sinks empty', () => {
             subject();
-            startJourney(def);
+            moduleRuntime.startJourney(def);
             completeJourney(def.name);
 
             expect(emitMock).not.toHaveBeenCalled();
@@ -103,7 +106,7 @@ describe('[journey] resetJourney', () => {
         let stepPromise: Promise<unknown>;
 
         beforeEach(() => {
-            startJourney(def);
+            moduleRuntime.startJourney(def);
             const hang = new Promise<void>(resolve => {
                 resolveWork = resolve;
             });
@@ -120,18 +123,31 @@ describe('[journey] resetJourney', () => {
         const subject = () => resetJourney({ sinks: [emitMock] });
 
         test('clears the ambient step', () => {
-            expect(activeJourneyStep()).not.toBeNull();
+            expect(singleInFlightJourneyStep()).not.toBeNull();
 
             subject();
 
-            expect(activeJourneyStep()).toBeNull();
+            expect(singleInFlightJourneyStep()).toBeNull();
+        });
+
+        test('reuses the same ambient stamp while the active step is unchanged', async () => {
+            const first = singleInFlightJourneyStep();
+            const second = singleInFlightJourneyStep();
+
+            expect(first).not.toBeNull();
+            expect(second).toBe(first);
+
+            resolveWork();
+            await stepPromise;
+
+            expect(singleInFlightJourneyStep()).toBeNull();
         });
     });
 
     describe('when a journey countdown is armed', () => {
         beforeEach(() => {
             jest.useFakeTimers();
-            startJourney({ ...def, timeoutMs: 50 });
+            moduleRuntime.startJourney({ ...def, timeoutMs: 50 });
         });
 
         afterEach(() => {
@@ -157,26 +173,42 @@ describe('[journey] createJourneyRuntime', () => {
     let runtime: ReturnType<typeof createJourneyRuntime>;
 
     beforeEach(() => {
+        setJourneyDefaultEnabled(true);
         resetJourney({
             sinks: [defaultEmit],
-            requestTimeouts: { defaultMs: 4_000, endpoints: [] },
+            slowRequests: { defaultMs: 4_000, endpoints: [] },
         });
         defaultEmit.mockClear();
         isolatedEmit.mockClear();
         runtime = createJourneyRuntime({ sinks: [isolatedEmit] });
     });
 
+    test('auto-assigns a unique runtime-N id when registered without an id', () => {
+        registerJourneyRuntime(runtime);
+
+        expect(moduleRuntime.id).toMatch(/^runtime-\d+$/);
+        expect(runtime.id).toMatch(/^runtime-\d+$/);
+        expect(runtime.id).not.toBe(moduleRuntime.id);
+    });
+
+    test('uses the provided id', () => {
+        const named = createJourneyRuntime({ id: 'job-booking', sinks: [isolatedEmit] });
+        expect(named.id).toBe('job-booking');
+    });
+
     afterEach(() => {
+        setJourneyDefaultEnabled(false);
+        localStorage.clear();
         resetJourney({
-            sinks: [sendToDatadog],
-            requestTimeouts: { defaultMs: 4_000, endpoints: [] },
+            sinks: [sendToDatadog, sendToConsole],
+            slowRequests: { defaultMs: 4_000, endpoints: [] },
         });
     });
 
     describe('when both runtimes open a journey', () => {
         beforeEach(() => {
             runtime.startJourney(def);
-            startJourney({ ...def, name: 'default-side' });
+            moduleRuntime.startJourney({ ...def, name: 'default-side' });
         });
 
         const subject = () => {
@@ -192,30 +224,32 @@ describe('[journey] createJourneyRuntime', () => {
         });
     });
 
-    describe('when the isolated runtime has its own requestTimeouts', () => {
+    describe('when the isolated runtime has its own slowRequests', () => {
         beforeEach(() => {
             runtime = createJourneyRuntime({
                 sinks: [isolatedEmit],
-                requestTimeouts: { defaultMs: 10, endpoints: [] },
+                slowRequests: { defaultMs: 10, endpoints: [] },
             });
-            configureJourney({ requestTimeouts: { defaultMs: 9_000, endpoints: [] } });
+            configureJourney({ slowRequests: { defaultMs: 9_000, endpoints: [] } });
         });
 
-        test('keeps timeouts separate from the default engine', () => {
-            expect(runtime.getRequestTimeouts().defaultMs).toBe(10);
-            expect(getRequestTimeouts().defaultMs).toBe(9_000);
+        test('inherits shared host thresholds unless this runtime overlays', () => {
+            expect(runtime.getSlowRequests().defaultMs).toBe(9_000);
+            runtime.setPolicyOverlay({ slowRequests: { defaultMs: 10, endpoints: [] } });
+            expect(runtime.getSlowRequests().defaultMs).toBe(10);
+            expect(getSlowRequests().defaultMs).toBe(9_000);
         });
     });
 
     describe('when the isolated runtime is reset', () => {
         beforeEach(() => {
             runtime.startJourney(def);
-            startJourney({ ...def, name: 'default-side' });
+            moduleRuntime.startJourney({ ...def, name: 'default-side' });
         });
 
         const subject = () => runtime.reset({ sinks: [isolatedEmit] });
 
-        test('does not clear the default engine', () => {
+        test('does not clear the module engine', () => {
             subject();
             completeJourney('default-side');
 
@@ -227,10 +261,10 @@ describe('[journey] createJourneyRuntime', () => {
     describe('when defineJourney is used', () => {
         const subject = () =>
             defineJourney(def).step('load', step => {
-                step.complete();
+                step.completeJourney();
             });
 
-        test('binds to the default runtime', async () => {
+        test('binds to the module runtime', async () => {
             await subject();
 
             expect(defaultEmit).toHaveBeenCalledTimes(1);
@@ -270,4 +304,17 @@ describe('[journey] createJourneyRuntime', () => {
             expect(isolatedEmit).toHaveBeenCalledTimes(1);
         });
     });
+
+    describe('maxSteps bounds', () => {
+        test('clamps invalid and oversized values', () => {
+            moduleRuntime.setMaxSteps(Infinity);
+            expect(moduleRuntime.getMaxSteps()).toBe(50);
+            moduleRuntime.setMaxSteps(0);
+            expect(moduleRuntime.getMaxSteps()).toBe(50);
+            moduleRuntime.setMaxSteps(500);
+            expect(moduleRuntime.getMaxSteps()).toBe(200);
+            moduleRuntime.setMaxSteps(Number.NaN);
+            expect(moduleRuntime.getMaxSteps()).toBe(50);
+        });
+    });
 });

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

@@ -0,0 +1,69 @@
+/** @jest-environment jsdom */
+import { MAX_ATTRIBUTE_KEYS, MAX_TAG_KEYS, isUnsafeKey } from '../../core/limits';
+import { assignRecord, copyRecord, emptyRecord, sanitizeJourneyEvent } from '../../core/sanitize';
+import type { JourneyEvent } from '../../core/types';
+
+describe('[journey] sanitize / copyRecord', () => {
+    test('isUnsafeKey blocks proto and secret names', () => {
+        expect(isUnsafeKey('__proto__')).toBe(true);
+        expect(isUnsafeKey('constructor')).toBe(true);
+        expect(isUnsafeKey('Authorization')).toBe(true);
+        expect(isUnsafeKey('token')).toBe(true);
+        expect(isUnsafeKey('customer.id')).toBe(false);
+    });
+
+    test('JSON __proto__ assign does not pollute Object.prototype', () => {
+        const target = emptyRecord();
+        const polluted = JSON.parse('{"__proto__":{"polluted":true},"ok":1}') as Record<
+            string,
+            unknown
+        >;
+        assignRecord(target, polluted, MAX_TAG_KEYS);
+        expect(target.ok).toBe(1);
+        expect(({} as { polluted?: boolean }).polluted).toBeUndefined();
+        expect(Object.prototype.hasOwnProperty.call(target, '__proto__')).toBe(false);
+    });
+
+    test('copyRecord caps keys and drops secrets', () => {
+        const src: Record<string, string | number> = { token: 'secret', keep: 1 };
+        for (let i = 0; i < MAX_ATTRIBUTE_KEYS + 5; i += 1) {
+            src[`k${i}`] = i;
+        }
+        const out = copyRecord(src, { maxKeys: MAX_ATTRIBUTE_KEYS, normalizeKeys: true });
+        expect(out.token).toBeUndefined();
+        expect(Object.keys(out).length).toBe(MAX_ATTRIBUTE_KEYS);
+    });
+
+    test('sanitizeJourneyEvent normalizes step names and tag keys', () => {
+        const event: JourneyEvent = {
+            journey: {
+                name: 'Make A Sale!!',
+                team: 'Sales',
+                group: 'retail',
+                service: 'checkout',
+                outcome: 'good',
+                durationMs: 10,
+                expected: ['Create Sale'],
+                tags: { 'User Email': 'a@b.com', 'token': 'nope', 'plan': 'Pro' },
+                steps: [
+                    {
+                        name: 'Load Customer 1',
+                        startMs: 0,
+                        durationMs: 4,
+                        outcome: 'good',
+                        attributes: { 'token': 'x', 'Draft.id': 'abc' },
+                    },
+                ],
+            },
+        };
+        const j = sanitizeJourneyEvent(event).journey;
+        expect(j.name).toBe('make_a_sale');
+        expect(j.expected).toEqual(['create_sale']);
+        expect(j.steps[0].name).toBe('load_customer_1');
+        expect(j.tags?.user_email).toBe('a_b.com');
+        expect(j.tags?.token).toBeUndefined();
+        expect(j.tags?.plan).toBe('pro');
+        expect(j.steps[0].attributes?.token).toBeUndefined();
+        expect(j.steps[0].attributes?.['draft.id']).toBe('abc');
+    });
+});