@servicetitan/journey 2.1.0 → 3.0.1

package/dist/core/runtime.js

@@ -1,35 +1,89 @@
-import { longestEndpointMatch, sortEndpointsByLongestMatch } from './endpoint-policy';
-import { JourneyStepTag } from './step-tag';
-const DEFAULT_REQUEST_TIMEOUTS = {
+import { getAutoAttributeRequests as getSharedAutoAttributeRequests, getHttpAbortedRequestsPolicy as getSharedHttpAbortedRequestsPolicy, getHttpClientErrorRequestsPolicy as getSharedHttpClientErrorRequestsPolicy, getSharedSlowRequests, isJourneyDebugEnabled } from '../global';
+import { isCanceledError } from './abort-error';
+import { resolveEndpointPolicy, sortEndpointsByLongestMatch } from './endpoint-policy';
+import { clampMaxSteps, DEFAULT_MAX_STEPS, DEFAULT_JOURNEY_IDLE_MS, finiteSlowRequestMs, finiteTimeoutMs, MAX_ATTRIBUTED_REQUEST_KEYS, MAX_TAG_KEYS, resolveJourneyTimeoutMs } from './limits';
+import { assignRecord, emptyRecord, sanitizeJourneyEvent, setSafeAttribute } from './sanitize';
+import { JourneyStepStamp, resolveStampOpts } from './step-tag';
+import { JOURNEY_ENGINE } from './types';
+const DEFAULT_SLOW_REQUESTS = {
     defaultMs: 4000,
     endpoints: []
 };
 const noopStep = {
-    name: null,
+    journeyName: null,
     setAttribute () {},
     setTags () {},
-    complete () {},
-    fail () {},
-    tag: ()=>({})
+    completeJourney () {},
+    failJourney () {},
+    stamp: ()=>undefined
 };
 function toName(target) {
-    return typeof target === 'string' ? target : target.name;
+    if (typeof target === 'string') {
+        return target;
+    }
+    return 'config' in target ? target.config.name : target.name;
+}
+function freezeJourneyDef(config, tags) {
+    const endpoints = sortEndpointsByLongestMatch(config.endpoints);
+    return Object.freeze({
+        ...config,
+        timeoutMs: config.timeoutMs !== undefined ? finiteTimeoutMs(config.timeoutMs) : undefined,
+        stepTimeoutMs: config.stepTimeoutMs !== undefined ? finiteTimeoutMs(config.stepTimeoutMs) : undefined,
+        slowRequestMs: finiteSlowRequestMs(config.slowRequestMs),
+        maxSteps: config.maxSteps !== undefined ? clampMaxSteps(config.maxSteps) : undefined,
+        endpoints: endpoints ? Object.freeze([
+            ...endpoints
+        ]) : undefined,
+        expected: config.expected ? Object.freeze([
+            ...config.expected
+        ]) : undefined,
+        tags: Object.freeze({
+            ...tags
+        })
+    });
+}
+function bindJourneyEngine(api, journey, shouldIgnoreRequest) {
+    return {
+        failJourney (reason) {
+            api.failJourney(journey, reason);
+        },
+        exclude () {
+            api.excludeJourney(journey);
+        },
+        shouldIgnoreRequest (key) {
+            return shouldIgnoreRequest(journey, key);
+        },
+        reportBackendRequest (step, status, durationMs, requestKey) {
+            api.reportBackendRequest(step, status, durationMs, requestKey);
+        },
+        getHttpAbortedRequestsPolicy () {
+            return api.getHttpAbortedRequestsPolicy();
+        },
+        getHttpClientErrorRequestsPolicy () {
+            return api.getHttpClientErrorRequestsPolicy();
+        }
+    };
 }
 /**
  * @internal Private — not part of the public package API.
  * Build an isolated engine. Rarely needed — apps use the default via free helpers.
  */ export function createJourneyRuntime(options = {}) {
-    var _options_sinks, _ref, _ref1;
-    var _options_requestTimeouts, _options_requestTimeouts1;
+    var _options_sinks, _ref, _ref1, _options_maxSteps, _options_defaultJourneyIdleMs;
+    var _options_slowRequests, _options_slowRequests1;
+    let id = typeof options.id === 'string' && options.id !== '' ? options.id : '';
     const journeys = new Map();
     const inFlight = new Set();
     let sinks = [
         ...(_options_sinks = options.sinks) !== null && _options_sinks !== void 0 ? _options_sinks : []
     ];
-    let requestTimeouts = {
-        defaultMs: (_ref = (_options_requestTimeouts = options.requestTimeouts) === null || _options_requestTimeouts === void 0 ? void 0 : _options_requestTimeouts.defaultMs) !== null && _ref !== void 0 ? _ref : DEFAULT_REQUEST_TIMEOUTS.defaultMs,
-        endpoints: sortEndpointsByLongestMatch((_ref1 = (_options_requestTimeouts1 = options.requestTimeouts) === null || _options_requestTimeouts1 === void 0 ? void 0 : _options_requestTimeouts1.endpoints) !== null && _ref1 !== void 0 ? _ref1 : DEFAULT_REQUEST_TIMEOUTS.endpoints)
+    let sinksConfigured = false;
+    let overlay = {};
+    let slowRequests = {
+        defaultMs: (_ref = (_options_slowRequests = options.slowRequests) === null || _options_slowRequests === void 0 ? void 0 : _options_slowRequests.defaultMs) !== null && _ref !== void 0 ? _ref : DEFAULT_SLOW_REQUESTS.defaultMs,
+        endpoints: sortEndpointsByLongestMatch((_ref1 = (_options_slowRequests1 = options.slowRequests) === null || _options_slowRequests1 === void 0 ? void 0 : _options_slowRequests1.endpoints) !== null && _ref1 !== void 0 ? _ref1 : DEFAULT_SLOW_REQUESTS.endpoints)
     };
+    let maxSteps = clampMaxSteps((_options_maxSteps = options.maxSteps) !== null && _options_maxSteps !== void 0 ? _options_maxSteps : DEFAULT_MAX_STEPS);
+    let defaultJourneyIdleMs = finiteTimeoutMs((_options_defaultJourneyIdleMs = options.defaultJourneyIdleMs) !== null && _options_defaultJourneyIdleMs !== void 0 ? _options_defaultJourneyIdleMs : DEFAULT_JOURNEY_IDLE_MS);
     function getInFlightSteps(journey) {
         const out = [];
         for (const step of inFlight){
@@ -45,6 +99,19 @@ function toName(target) {
     function leaveStep(step) {
         inFlight.delete(step);
     }
+    function releaseInFlightSteps(journey) {
+        for (const step of [
+            ...inFlight
+        ]){
+            if (step.journey !== journey) {
+                continue;
+            }
+            if (step.durationMs === 0) {
+                step.durationMs = Math.round(globalThis.performance.now() - step.startedAt);
+            }
+            inFlight.delete(step);
+        }
+    }
     function clearCountdown(journey) {
         if (journey.timer != null) {
             clearTimeout(journey.timer);
@@ -52,9 +119,10 @@ function toName(target) {
         }
     }
     function emit(payload) {
+        const safePayload = sanitizeJourneyEvent(payload);
         for (const sink of sinks){
             try {
-                sink(payload);
+                sink(safePayload);
             } catch (unused) {
             // One sinking throw must not block the remaining sinks.
             }
@@ -66,17 +134,15 @@ function toName(target) {
             return;
         }
         journey.closed = true;
-        journeys.delete(journey.name);
-        clearCountdown(journey);
-        for (const step of getInFlightSteps(journey)){
-            if (step.durationMs === 0) {
-                step.durationMs = Math.round(globalThis.performance.now() - step.startedAt);
-            }
+        if (journeys.get(journey.name) === journey) {
+            journeys.delete(journey.name);
         }
+        clearCountdown(journey);
+        releaseInFlightSteps(journey);
         let finalReason = (_journey_reason = journey.reason) !== null && _journey_reason !== void 0 ? _journey_reason : reason;
         let finalOutcome = outcome;
         const durationMs = Math.round(globalThis.performance.now() - journey.startedAt);
-        if (journey.timeoutMs > 0 && durationMs > journey.timeoutMs) {
+        if (journey.timeoutExplicit && journey.timeoutMs > 0 && durationMs > journey.timeoutMs) {
             finalOutcome = 'bad';
             finalReason = finalReason !== null && finalReason !== void 0 ? finalReason : 'journey-timeout';
         }
@@ -92,7 +158,9 @@ function toName(target) {
                     httpStatus: s.httpStatus
                 } : {},
                 ...Object.keys(s.attributes).length ? {
-                    attributes: s.attributes
+                    attributes: {
+                        ...s.attributes
+                    }
                 } : {}
             }));
         emit({
@@ -102,7 +170,7 @@ function toName(target) {
                 group: journey.group,
                 service: journey.service,
                 outcome: finalOutcome,
-                ...finalOutcome === 'bad' && finalReason ? {
+                ...finalReason ? {
                     reason: finalReason
                 } : {},
                 durationMs,
@@ -111,40 +179,44 @@ function toName(target) {
                     expected: journey.expected
                 } : {},
                 ...Object.keys(journey.tags).length ? {
-                    tags: journey.tags
+                    tags: {
+                        ...journey.tags
+                    }
                 } : {}
             }
         });
     }
-    function armCountdown(journey) {
-        if (journey.timeoutMs <= 0) {
+    function armCountdown(journey, delayMs = journey.timeoutMs) {
+        if (delayMs <= 0) {
             return;
         }
         journey.timer = setTimeout(()=>{
-            finish(journey, 'bad', 'journey-timeout');
-        }, journey.timeoutMs);
+            if (journey.timeoutExplicit) {
+                finish(journey, 'bad', 'journey-timeout');
+                return;
+            }
+            finish(journey, journey.verdict === 'bad' ? 'bad' : 'excluded', 'journey-idle-timeout');
+        }, delayMs);
     }
-    function resolveRequestTimeoutMs(journey, key) {
-        const own = longestEndpointMatch(journey.endpoints, key);
-        if (own === null || own === void 0 ? void 0 : own.timeoutMs) {
-            return own.timeoutMs;
-        }
-        const app = longestEndpointMatch(requestTimeouts.endpoints, key);
-        if (app === null || app === void 0 ? void 0 : app.timeoutMs) {
-            return app.timeoutMs;
-        }
-        if (journey.requestTimeoutMs != null) {
-            return journey.requestTimeoutMs;
-        }
-        return requestTimeouts.defaultMs;
+    function effectiveSlowRequests() {
+        var _ref, _overlay_slowRequests;
+        return (_ref = (_overlay_slowRequests = overlay.slowRequests) !== null && _overlay_slowRequests !== void 0 ? _overlay_slowRequests : getSharedSlowRequests()) !== null && _ref !== void 0 ? _ref : slowRequests;
     }
     function shouldIgnoreRequest(journey, key) {
-        var _longestEndpointMatch;
-        const own = longestEndpointMatch(journey.endpoints, key);
-        if (own) {
-            return own.ignore === true;
+        return resolveEndpointPolicy(journey, effectiveSlowRequests(), key).ignore;
+    }
+    function trackAttributedKey(step, requestKey) {
+        var _step, _attributedRequestKeys;
+        if (!requestKey) {
+            return;
+        }
+        (_attributedRequestKeys = (_step = step).attributedRequestKeys) !== null && _attributedRequestKeys !== void 0 ? _attributedRequestKeys : _step.attributedRequestKeys = [];
+        if (step.attributedRequestKeys.length >= MAX_ATTRIBUTED_REQUEST_KEYS) {
+            return;
+        }
+        if (!step.attributedRequestKeys.includes(requestKey)) {
+            step.attributedRequestKeys.push(requestKey);
         }
-        return ((_longestEndpointMatch = longestEndpointMatch(requestTimeouts.endpoints, key)) === null || _longestEndpointMatch === void 0 ? void 0 : _longestEndpointMatch.ignore) === true;
     }
     function resolveJourneyName(journey) {
         if (journey == null) {
@@ -153,54 +225,126 @@ function toName(target) {
         if (typeof journey === 'string' || !Array.isArray(journey)) {
             return toName(journey);
         }
-        return api.firstOpenJourney(journey.map(toName));
+        return api.firstOpenJourneyName(journey.map(toName));
+    }
+    function configFromTarget(target) {
+        if (typeof target === 'string') {
+            return undefined;
+        }
+        if ('config' in target && target.config != null && typeof target.config === 'object') {
+            return target.config;
+        }
+        const rec = target;
+        if (typeof rec.name === 'string' && typeof rec.team === 'string' && typeof rec.group === 'string' && typeof rec.service === 'string') {
+            return target;
+        }
+        return undefined;
+    }
+    function maybeAutoStart(target) {
+        if (target == null || typeof target === 'string' || Array.isArray(target)) {
+            return;
+        }
+        const def = configFromTarget(target);
+        if (def && !api.getOpenJourney(def.name)) {
+            api.startJourney(def);
+        }
     }
     function createStepHandle(journeyName, step) {
         return {
-            name: journeyName,
+            journeyName,
             setAttribute (key, value) {
-                step.attributes[key] = value;
+                setSafeAttribute(step.attributes, key, value);
             },
             setTags (tags) {
-                api.setJourneyTags(journeyName, tags);
+                if (step.journey.closed) {
+                    return;
+                }
+                assignRecord(step.journey.tags, tags, MAX_TAG_KEYS);
             },
-            complete (tags) {
-                api.completeJourney(journeyName, tags);
+            completeJourney (tags) {
+                api.completeJourneyState(step.journey, tags);
             },
-            fail (reason) {
-                api.failJourney(journeyName, reason);
+            failJourney (reason) {
+                api.failJourney(step.journey, reason);
             },
-            // Box in JourneyStepTag — raw StepRecord is circular and blows jQuery/axios deep-merge.
-            tag: ()=>({
-                    journeyStep: new JourneyStepTag(step)
-                })
+            // Box in JourneyStepStamp — raw StepRecord is circular and blows jQuery/axios deep-merge.
+            stamp: (scoreOrOpts)=>new JourneyStepStamp(step, resolveStampOpts(scoreOrOpts))
         };
     }
     const api = {
-        getRequestTimeouts () {
-            return requestTimeouts;
+        get id () {
+            return id;
         },
-        setRequestTimeouts (next) {
-            requestTimeouts = {
-                ...next,
-                endpoints: sortEndpointsByLongestMatch(next.endpoints)
+        set id (next){
+            id = next;
+        },
+        getSlowRequests () {
+            return effectiveSlowRequests();
+        },
+        setSlowRequests (next1) {
+            slowRequests = {
+                ...next1,
+                endpoints: sortEndpointsByLongestMatch(next1.endpoints)
             };
         },
-        setSinks (next) {
+        getMaxSteps () {
+            return maxSteps;
+        },
+        setMaxSteps (next1) {
+            maxSteps = clampMaxSteps(next1);
+        },
+        getDefaultJourneyIdleMs () {
+            return defaultJourneyIdleMs;
+        },
+        setDefaultJourneyIdleMs (next1) {
+            defaultJourneyIdleMs = finiteTimeoutMs(next1);
+        },
+        setSinks (next1) {
             sinks = [
-                ...next
+                ...next1
             ];
         },
+        trySetConfiguredSinks (next1) {
+            if (sinksConfigured) {
+                return false;
+            }
+            sinks = [
+                ...next1
+            ];
+            sinksConfigured = true;
+            return true;
+        },
         addSink (sink) {
             sinks.push(sink);
         },
         emit,
+        setPolicyOverlay (next1) {
+            overlay = {
+                ...overlay,
+                ...next1
+            };
+        },
+        getAutoAttributeRequests () {
+            if (overlay.autoAttributeRequests !== undefined) {
+                return overlay.autoAttributeRequests;
+            }
+            return getSharedAutoAttributeRequests();
+        },
+        getHttpAbortedRequestsPolicy () {
+            var _overlay_httpAbortedRequests;
+            return (_overlay_httpAbortedRequests = overlay.httpAbortedRequests) !== null && _overlay_httpAbortedRequests !== void 0 ? _overlay_httpAbortedRequests : getSharedHttpAbortedRequestsPolicy();
+        },
+        getHttpClientErrorRequestsPolicy () {
+            var _overlay_httpClientErrorRequests;
+            return (_overlay_httpClientErrorRequests = overlay.httpClientErrorRequests) !== null && _overlay_httpClientErrorRequests !== void 0 ? _overlay_httpClientErrorRequests : getSharedHttpClientErrorRequestsPolicy();
+        },
         getOpenJourney (name) {
             return journeys.get(name);
         },
         getDebugSnapshot () {
             const active = api.activeJourneyStep();
             return {
+                id: api.id,
                 openJourneys: [
                     ...journeys.values()
                 ].map((journey)=>({
@@ -214,22 +358,36 @@ function toName(target) {
                             ...journey.tags
                         },
                         stepsInFlight: getInFlightSteps(journey).map((step)=>step.name),
-                        steps: journey.steps.map((step)=>({
+                        steps: journey.steps.map((step)=>{
+                            var _step_attributedRequestKeys;
+                            return {
                                 name: step.name,
                                 outcome: step.outcome,
                                 durationMs: step.durationMs,
                                 ...step.reason ? {
                                     reason: step.reason
+                                } : {},
+                                ...((_step_attributedRequestKeys = step.attributedRequestKeys) === null || _step_attributedRequestKeys === void 0 ? void 0 : _step_attributedRequestKeys.length) ? {
+                                    attributedRequestKeys: [
+                                        ...step.attributedRequestKeys
+                                    ]
                                 } : {}
-                            }))
+                            };
+                        })
                     })),
                 activeStep: active ? {
                     journey: active.journey.name,
                     name: active.name
-                } : null
+                } : null,
+                policyOverlay: {
+                    slowRequests: overlay.slowRequests != null,
+                    httpAbortedRequests: overlay.httpAbortedRequests != null,
+                    httpClientErrorRequests: overlay.httpClientErrorRequests != null,
+                    autoAttributeRequests: overlay.autoAttributeRequests != null
+                }
             };
         },
-        firstOpenJourney (names) {
+        firstOpenJourneyName (names) {
             for (const name of names){
                 if (journeys.has(name)) {
                     return name;
@@ -240,41 +398,46 @@ function toName(target) {
         setJourneyTags (name, tags) {
             const journey = name ? journeys.get(name) : undefined;
             if (journey) {
-                Object.assign(journey.tags, tags);
+                assignRecord(journey.tags, tags, MAX_TAG_KEYS);
             }
         },
-        startJourney (def) {
-            var _def_timeoutMs, _def_tags;
-            const existing = journeys.get(def.name);
+        startJourney (config) {
+            const existing = journeys.get(config.name);
             if (existing) {
                 finish(existing, existing.verdict === 'bad' ? 'bad' : 'excluded');
             }
+            const tags = emptyRecord();
+            assignRecord(tags, config.tags, MAX_TAG_KEYS);
+            const snapshot = freezeJourneyDef(config, tags);
+            const timeout = resolveJourneyTimeoutMs(snapshot.timeoutMs, defaultJourneyIdleMs);
             const journey = {
-                name: def.name,
-                team: def.team,
-                group: def.group,
-                service: def.service,
+                config: snapshot,
+                name: snapshot.name,
+                team: snapshot.team,
+                group: snapshot.group,
+                service: snapshot.service,
                 verdict: 'good',
                 startedAt: globalThis.performance.now(),
-                timeoutMs: (_def_timeoutMs = def.timeoutMs) !== null && _def_timeoutMs !== void 0 ? _def_timeoutMs : 0,
-                stepTimeoutMs: def.stepTimeoutMs,
+                timeoutMs: timeout.ms,
+                timeoutExplicit: timeout.explicit,
+                stepTimeoutMs: snapshot.stepTimeoutMs !== undefined ? finiteTimeoutMs(snapshot.stepTimeoutMs) : undefined,
                 reason: null,
                 steps: [],
-                expected: def.steps ? [
-                    ...def.steps
+                expected: snapshot.expected ? [
+                    ...snapshot.expected
                 ] : null,
-                tags: {
-                    ...(_def_tags = def.tags) !== null && _def_tags !== void 0 ? _def_tags : {}
-                },
-                requestTimeoutMs: def.requestTimeoutMs,
-                endpoints: sortEndpointsByLongestMatch(def.endpoints),
+                tags,
+                slowRequestMs: finiteSlowRequestMs(snapshot.slowRequestMs),
+                endpoints: snapshot.endpoints,
                 timer: null,
-                closed: false
+                closed: false,
+                maxSteps: snapshot.maxSteps !== undefined ? clampMaxSteps(snapshot.maxSteps) : undefined
             };
-            journeys.set(def.name, journey);
+            journeys.set(config.name, journey);
+            journey[JOURNEY_ENGINE] = bindJourneyEngine(api, journey, shouldIgnoreRequest);
             armCountdown(journey);
         },
-        failJourneyNow (journey, reason) {
+        failJourney (journey, reason) {
             var _journey, _reason;
             if (journey.closed) {
                 return;
@@ -283,42 +446,87 @@ function toName(target) {
             (_reason = (_journey = journey).reason) !== null && _reason !== void 0 ? _reason : _journey.reason = reason;
             finish(journey, 'bad');
         },
-        failJourney (name, reason) {
+        completeJourney (name, tags) {
+            if (!name) {
+                return;
+            }
             const journey = journeys.get(name);
             if (journey) {
-                api.failJourneyNow(journey, reason);
+                api.completeJourneyState(journey, tags);
             }
         },
-        completeJourney (name, tags) {
-            if (!name) {
+        completeJourneyState (journey, tags) {
+            if (journey.closed) {
                 return;
             }
             if (tags) {
-                api.setJourneyTags(name, tags);
+                assignRecord(journey.tags, tags, MAX_TAG_KEYS);
             }
-            const journey = journeys.get(name);
-            if (journey) {
-                finish(journey, journey.verdict === 'bad' ? 'bad' : 'good');
+            finish(journey, journey.verdict === 'bad' ? 'bad' : 'good');
+        },
+        excludeJourney (journey) {
+            if (journey.closed) {
+                return;
             }
+            finish(journey, journey.verdict === 'bad' ? 'bad' : 'excluded');
         },
-        excludeJourney (name) {
-            const journey = journeys.get(name);
-            if (journey) {
-                finish(journey, journey.verdict === 'bad' ? 'bad' : 'excluded');
+        updateOpenJourney (config) {
+            const journey = journeys.get(config.name);
+            if (!journey || journey.closed) {
+                return;
+            }
+            journey.team = config.team;
+            journey.group = config.group;
+            journey.service = config.service;
+            const timeout = resolveJourneyTimeoutMs(config.timeoutMs, defaultJourneyIdleMs);
+            journey.timeoutMs = timeout.ms;
+            journey.timeoutExplicit = timeout.explicit;
+            journey.stepTimeoutMs = config.stepTimeoutMs !== undefined ? finiteTimeoutMs(config.stepTimeoutMs) : undefined;
+            journey.slowRequestMs = finiteSlowRequestMs(config.slowRequestMs);
+            journey.endpoints = sortEndpointsByLongestMatch(config.endpoints);
+            journey.expected = config.expected ? [
+                ...config.expected
+            ] : null;
+            journey.maxSteps = config.maxSteps !== undefined ? clampMaxSteps(config.maxSteps) : undefined;
+            if (config.tags) {
+                assignRecord(journey.tags, config.tags, MAX_TAG_KEYS);
+            }
+            clearCountdown(journey);
+            if (journey.timeoutMs <= 0) {
+                return;
             }
+            const elapsedMs = globalThis.performance.now() - journey.startedAt;
+            const remainingMs = journey.timeoutMs - elapsedMs;
+            if (remainingMs <= 0) {
+                if (journey.timeoutExplicit) {
+                    finish(journey, 'bad', 'journey-timeout');
+                    return;
+                }
+                finish(journey, journey.verdict === 'bad' ? 'bad' : 'excluded', 'journey-idle-timeout');
+                return;
+            }
+            armCountdown(journey, remainingMs);
         },
         activeJourneyStep () {
             var _inFlight_values_next_value;
+            if (!api.getAutoAttributeRequests()) {
+                return null;
+            }
             if (inFlight.size !== 1) {
                 return null;
             }
             return (_inFlight_values_next_value = inFlight.values().next().value) !== null && _inFlight_values_next_value !== void 0 ? _inFlight_values_next_value : null;
         },
         async journeyStep (journey, stepName, fn, opts) {
-            var _ref, _ref1;
+            var _open_maxSteps, _ref, _ref1;
+            maybeAutoStart(journey);
             const journeyName = resolveJourneyName(journey);
             const open = journeyName ? journeys.get(journeyName) : undefined;
             if (!open || !journeyName) {
+                if (isJourneyDebugEnabled()) {
+                    // eslint-disable-next-line no-console -- debug-only untraced hint
+                    console.debug(`[journey] step "${stepName}" ran untraced (no open journey)`);
+                }
                 return fn(noopStep);
             }
             const step = {
@@ -326,10 +534,15 @@ function toName(target) {
                 startedAt: globalThis.performance.now(),
                 durationMs: 0,
                 outcome: 'good',
-                attributes: {},
+                attributes: emptyRecord(),
                 journey: open
             };
-            open.steps.push(step);
+            const cap = (_open_maxSteps = open.maxSteps) !== null && _open_maxSteps !== void 0 ? _open_maxSteps : maxSteps;
+            if (open.steps.length >= cap) {
+                open.tags.steps_truncated = true;
+            } else {
+                open.steps.push(step);
+            }
             const handle = createStepHandle(journeyName, step);
             const stepTimeoutMs = (_ref = (_ref1 = opts === null || opts === void 0 ? void 0 : opts.timeoutMs) !== null && _ref1 !== void 0 ? _ref1 : open.stepTimeoutMs) !== null && _ref !== void 0 ? _ref : 0;
             let timeoutTimer = null;
@@ -343,19 +556,23 @@ function toName(target) {
                     (_reason = (_step = step).reason) !== null && _reason !== void 0 ? _reason : _step.reason = 'step-timeout';
                     (_timeout_ms = (_step_attributes = step.attributes).timeout_ms) !== null && _timeout_ms !== void 0 ? _timeout_ms : _step_attributes.timeout_ms = stepTimeoutMs;
                     step.durationMs = Math.round(globalThis.performance.now() - step.startedAt);
-                    api.failJourneyNow(open, 'step-timeout');
+                    api.failJourney(open, 'step-timeout');
                 }, stepTimeoutMs);
             }
             enterStep(step);
             try {
                 return await fn(handle);
             } catch (err) {
-                var _step, _reason, _step_attributes, _error;
-                const message = err instanceof Error ? err.message : String(err);
-                step.outcome = 'bad';
-                (_reason = (_step = step).reason) !== null && _reason !== void 0 ? _reason : _step.reason = 'step-error';
-                (_error = (_step_attributes = step.attributes).error) !== null && _error !== void 0 ? _error : _step_attributes.error = message;
-                api.failJourneyNow(open, 'step-error');
+                if (isCanceledError(err)) {
+                /*
+                     * Attributed abort is scored in onHttpComplete. Unattributed /
+                     * ignored abort throws must not apply policy (empty requestKey).
+                     */ } else {
+                    var _step, _reason;
+                    step.outcome = 'bad';
+                    (_reason = (_step = step).reason) !== null && _reason !== void 0 ? _reason : _step.reason = 'step-error';
+                    api.failJourney(open, 'step-error');
+                }
                 throw err;
             } finally{
                 if (timeoutTimer != null) {
@@ -371,20 +588,24 @@ function toName(target) {
             await Promise.resolve();
             return api.journeyStep(journey, stepName, fn, opts);
         },
+        shouldIgnoreRequest,
         reportBackendRequest (step, status, durationMs, requestKey) {
             var _step, _reason;
-            if (!step) {
+            if (!(step === null || step === void 0 ? void 0 : step.journey)) {
                 return;
             }
             const journey = step.journey;
             if (journey.closed) {
                 return;
             }
-            if (shouldIgnoreRequest(journey, requestKey)) {
+            trackAttributedKey(step, requestKey);
+            const endpointPolicy = resolveEndpointPolicy(journey, effectiveSlowRequests(), requestKey);
+            if (endpointPolicy.ignore) {
                 return;
             }
             const failed = status === undefined || status >= 500;
-            const slow = durationMs > resolveRequestTimeoutMs(journey, requestKey);
+            const threshold = endpointPolicy.slowRequestMs;
+            const slow = threshold > 0 && durationMs > threshold;
             if (!failed && !slow) {
                 return;
             }
@@ -394,11 +615,11 @@ function toName(target) {
             if (failed && status !== undefined) {
                 step.httpStatus = status;
             }
-            api.failJourneyNow(journey, category);
+            api.failJourney(journey, category);
         },
-        reset (next = {}) {
-            var _next_sinks, _ref, _ref1;
-            var _next_requestTimeouts, _next_requestTimeouts1;
+        reset (next1 = {}) {
+            var _next_sinks, _ref, _ref1, _next_defaultJourneyIdleMs;
+            var _next_slowRequests, _next_slowRequests1;
             for (const journey of [
                 ...journeys.values()
             ]){
@@ -407,13 +628,17 @@ function toName(target) {
             }
             journeys.clear();
             inFlight.clear();
+            overlay = {};
+            sinksConfigured = false;
             sinks = [
-                ...(_next_sinks = next.sinks) !== null && _next_sinks !== void 0 ? _next_sinks : []
+                ...(_next_sinks = next1.sinks) !== null && _next_sinks !== void 0 ? _next_sinks : []
             ];
-            requestTimeouts = {
-                defaultMs: (_ref = (_next_requestTimeouts = next.requestTimeouts) === null || _next_requestTimeouts === void 0 ? void 0 : _next_requestTimeouts.defaultMs) !== null && _ref !== void 0 ? _ref : DEFAULT_REQUEST_TIMEOUTS.defaultMs,
-                endpoints: sortEndpointsByLongestMatch((_ref1 = (_next_requestTimeouts1 = next.requestTimeouts) === null || _next_requestTimeouts1 === void 0 ? void 0 : _next_requestTimeouts1.endpoints) !== null && _ref1 !== void 0 ? _ref1 : DEFAULT_REQUEST_TIMEOUTS.endpoints)
+            slowRequests = {
+                defaultMs: (_ref = (_next_slowRequests = next1.slowRequests) === null || _next_slowRequests === void 0 ? void 0 : _next_slowRequests.defaultMs) !== null && _ref !== void 0 ? _ref : DEFAULT_SLOW_REQUESTS.defaultMs,
+                endpoints: sortEndpointsByLongestMatch((_ref1 = (_next_slowRequests1 = next1.slowRequests) === null || _next_slowRequests1 === void 0 ? void 0 : _next_slowRequests1.endpoints) !== null && _ref1 !== void 0 ? _ref1 : DEFAULT_SLOW_REQUESTS.endpoints)
             };
+            maxSteps = next1.maxSteps !== undefined ? clampMaxSteps(next1.maxSteps) : DEFAULT_MAX_STEPS;
+            defaultJourneyIdleMs = finiteTimeoutMs((_next_defaultJourneyIdleMs = next1.defaultJourneyIdleMs) !== null && _next_defaultJourneyIdleMs !== void 0 ? _next_defaultJourneyIdleMs : DEFAULT_JOURNEY_IDLE_MS);
         }
     };
     return api;
@@ -423,10 +648,62 @@ function toName(target) {
  * Module-scoped engine used by free helpers. App code does not need to touch this.
  * Each host/MFE bundle gets its own copy when the package is duplicated.
  */ export const moduleRuntime = createJourneyRuntime();
+const noopEngine = {
+    failJourney () {},
+    exclude () {},
+    shouldIgnoreRequest () {
+        return false;
+    },
+    reportBackendRequest () {},
+    getHttpAbortedRequestsPolicy () {
+        return 'continue';
+    },
+    getHttpClientErrorRequestsPolicy () {
+        return 'continue';
+    }
+};
+/**
+ * True when this bundle can fail/exclude/report the journey: stamped engine, or
+ * this runtime's own unstamped object. False for a foreign older-copy journey.
+ */ export function canRouteHttpToJourney(journey) {
+    return journey[JOURNEY_ENGINE] != null || moduleRuntime.getOpenJourney(journey.name) === journey;
+}
+/**
+ * @internal Prefer the creating engine on a journey (MFE `step.stamp()` on a host transport).
+ * Falls back to this bundle's module runtime only when this runtime owns the object.
+ * Unstamped foreign journeys (older package copies) are a no-op so a same-named
+ * host journey is not deleted from this map.
+ */ export function resolveJourneyEngine(journey) {
+    const stamped = journey[JOURNEY_ENGINE];
+    if (stamped) {
+        return stamped;
+    }
+    if (moduleRuntime.getOpenJourney(journey.name) !== journey) {
+        return noopEngine;
+    }
+    return {
+        failJourney (reason) {
+            moduleRuntime.failJourney(journey, reason);
+        },
+        exclude () {
+            moduleRuntime.excludeJourney(journey);
+        },
+        shouldIgnoreRequest (key) {
+            return moduleRuntime.shouldIgnoreRequest(journey, key);
+        },
+        reportBackendRequest (step, status, durationMs, requestKey) {
+            moduleRuntime.reportBackendRequest(step, status, durationMs, requestKey);
+        },
+        getHttpAbortedRequestsPolicy () {
+            return moduleRuntime.getHttpAbortedRequestsPolicy();
+        },
+        getHttpClientErrorRequestsPolicy () {
+            return moduleRuntime.getHttpClientErrorRequestsPolicy();
+        }
+    };
+}
 /**
- * @internal Accidentally exported — removing it is a breaking change, so it stays
- * for compatibility. Not part of the supported public API.
- * Reset the module engine (open journeys, ambient steps, sinks, request thresholds).
+ * @internal Reset the module engine (open journeys, ambient steps, sinks, slow-request thresholds).
  * Intended for tests — call in `beforeEach` / `afterEach` instead of manual cleanup.
  */ export function resetJourney(options) {
     moduleRuntime.reset(options);