@servicetitan/journey 2.1.0 → 3.0.0

package/src/__tests__/sinks/datadog.test.ts

@@ -84,6 +84,16 @@ describe('[journey] setJourneyRum / sendToDatadog', () => {
         });
     });
 
+    describe('when the resolved RUM stub has no addAction', () => {
+        test('is a no-op', () => {
+            (globalThis as Record<string, unknown>)[DD_RUM_KEY] = {};
+
+            expect(() => sendToDatadog(sampleEvent())).not.toThrow();
+            expect(importedAddAction).not.toHaveBeenCalled();
+            expect(addAction).not.toHaveBeenCalled();
+        });
+    });
+
     describe('when setJourneyRum is called while globalThis.DD_RUM is set', () => {
         test('logs a redundancy warning', () => {
             (globalThis as Record<string, unknown>)[DD_RUM_KEY] = { addAction: ddRumAddAction };
@@ -184,6 +194,43 @@ describe('[journey] setJourneyRum / sendToDatadog', () => {
         expect(normalizeTagValue('Foo@@@Bar___')).toBe('foo_bar');
     });
 
+    test('drops denied tag keys and normalizes tag keys on the wire', () => {
+        setJourneyRum({ addAction });
+        sendToDatadog(
+            sampleEvent({
+                tags: {
+                    'token': 'secret',
+                    'User Email': 'Pat!',
+                },
+                steps: [
+                    {
+                        name: 'Load Draft!!',
+                        startMs: 0,
+                        durationMs: 3,
+                        outcome: 'good',
+                        attributes: { token: 'nope', phase: 'Load' },
+                    },
+                ],
+            })
+        );
+
+        const ctx = addAction.mock.calls[0][1];
+        expect(ctx.journey.tags.token).toBeUndefined();
+        expect(ctx.journey.tags.user_email).toBe('pat');
+        expect(ctx.journey.steps[0].name).toBe('load_draft');
+        expect(ctx.journey.steps[0].attributes.token).toBeUndefined();
+        expect(ctx.journey.steps[0].attributes.phase).toBe('load');
+    });
+
+    test('truncates long tag values on the wire', () => {
+        setJourneyRum({ addAction });
+        const long = `x${'a'.repeat(250)}`;
+        sendToDatadog(sampleEvent({ tags: { note: long } }));
+
+        const ctx = addAction.mock.calls[0][1];
+        expect(ctx.journey.tags.note.length).toBeLessThanOrEqual(200);
+    });
+
     test('maps camelCase fields to Datadog snake_case wire keys', () => {
         setJourneyRum({ addAction });
         sendToDatadog(

package/src/config.ts

@@ -1,11 +1,15 @@
 import { moduleRuntime } from './core/runtime';
 import type { JourneySink } from './core/types';
-import { installJourneyGlobal, registerJourneyRuntime } from './global';
+import type { RequestPolicyConfig } from './core/request-policy';
 import {
-    sortEndpointsByLongestMatch,
-    type AppRequestTimeouts,
-    type EndpointPolicy,
-} from './core/endpoint-policy';
+    areSharedPoliciesLocked,
+    getSharedSlowRequests,
+    isJourneyEnabled,
+    registerJourneyRuntime,
+    seedSharedPolicies,
+    warnIfSlowRequestsUnset,
+} from './global';
+import { sortEndpointsByLongestMatch, type SlowRequestConfig } from './core/endpoint-policy';
 import { instrumentAxios, type AxiosLikeInstance } from './integrations/axios';
 import { instrumentFetch, type InstrumentFetchOptions } from './integrations/fetch';
 import {
@@ -14,34 +18,73 @@ import {
     type JqueryStatic,
     type WindowWithAppJourney,
 } from './integrations/jquery';
+import { resolveGlobalJquery } from './integrations/jquery/instrument';
 import { sendToConsole } from './sinks/console';
 import { sendToDatadog } from './sinks/datadog';
 
-export type { AppRequestTimeouts, EndpointPolicy };
-
 /** Optional app-wide / per-bundle configuration. */
 export interface JourneyConfig {
-    /** App-wide request-timeout fallback. Defaults to { defaultMs: 4000, endpoints: [] }. */
-    requestTimeouts?: AppRequestTimeouts;
+    /**
+     * App-wide slow-request thresholds (shared on `__stJourney` for all package copies).
+     * Package fallback remains `{ defaultMs: 4000, endpoints: [] }` until set.
+     * Desktop / KO hosts should set `defaultMs` and ignore noisy endpoint prefixes.
+     */
+    slowRequests?: SlowRequestConfig;
+    /**
+     * How attributed aborted/cancelled HTTP counts toward the open journey.
+     * Shared on `__stJourney`. Literal or `(ctx) => …`. Default `'continue'`.
+     */
+    httpAbortedRequests?: RequestPolicyConfig;
+    /**
+     * How attributed 4xx responses count toward the open journey.
+     * Shared on `__stJourney`. Literal or `(ctx) => …`. Default `'continue'` (no verdict change).
+     */
+    httpClientErrorRequests?: RequestPolicyConfig;
+    /**
+     * When true (default), untagged instrumented HTTP is attributed to the sole
+     * in-flight step (if exactly one). When false, only explicit `step.stamp()` attributes.
+     * Prefer false on busy desktop / shared jQuery shells with background traffic.
+     * Shared on `__stJourney`.
+     */
+    autoAttributeRequests?: boolean;
+    /**
+     * Default cap on recorded steps per journey (default 50). Per-journey
+     * `JourneyDef.maxSteps` overrides. Excess steps are dropped and
+     * `tags.steps_truncated` is set.
+     */
+    maxSteps?: number;
+    /**
+     * Applied when a journey omits `timeoutMs`.
+     * Default is 15m and closes as `excluded` with `journey-idle-timeout`.
+     * Pass `0` to disable this idle timeout.
+     */
+    defaultJourneyIdleMs?: number;
     /**
      * Replace the sink list used when a journey finishes.
      * Only applied when provided — omit to leave the current list unchanged.
      * Package default is `[sendToDatadog, sendToConsole]`; pass `[]` to disable emission.
-     * `sendToConsole` is a no-op unless `localStorage['st:journey:debug'] === 'true'`.
+     * `sendToConsole` is a no-op unless `sessionStorage['st:journey:debug'] === 'true'`.
+     * First `sinks` on this bundle wins; a later `configureJourney({ sinks })` is ignored.
      */
     sinks?: readonly JourneySink[];
     /**
      * Wire this bundle's axios instance (host or MFE). Same as `instrumentAxios(axios)`.
      * Register any async request interceptors (e.g. auth) before `configureJourney`.
+     * Soft-skips when axios is missing / not axios-like — safe to pass a host instance that may be absent.
      */
-    axios?: AxiosLikeInstance;
+    axios?: AxiosLikeInstance | null;
     /**
      * Wire fetch. `true` wraps `globalThis.fetch`; pass options for a scoped target / baseURL.
-     * Same as `instrumentFetch(...)`.
+     * Same as `instrumentFetch(...)`. Soft-skips when the target has no callable `fetch`.
+     * Prefer host-only for `globalThis.fetch` — MFEs inherit the host wrapper.
+     */
+    fetch?: true | InstrumentFetchOptions | null;
+    /**
+     * Wire jQuery. Pass a `$` instance, or `true` to use `globalThis.$` / `globalThis.jQuery`.
+     * `false` skips wiring. Soft-skips when `$` is missing / not real jQuery.
+     * Prefer host-only for shared `$`.
      */
-    fetch?: true | InstrumentFetchOptions;
-    /** Wire this bundle's jQuery static. Same as `instrumentJquery($)`. */
-    jquery?: JqueryStatic;
+    jquery?: boolean | JqueryStatic | null;
     /**
      * Publish `window.App.Journey` for Knockout / legacy hosts.
      * `true` uses the real window; pass a target object in tests.
@@ -55,41 +98,122 @@ export interface JourneyConfig {
  * `__stJourney`. configureJourney only replaces sinks when `sinks` is passed explicitly.
  */
 moduleRuntime.setSinks([sendToDatadog, sendToConsole]);
-installJourneyGlobal();
 registerJourneyRuntime(moduleRuntime);
 
 /**
  * Apply bundle options: request thresholds, sinks, and/or HTTP / legacy wiring.
  * Optional — call once at startup. Pass this bundle's own axios / `$` / fetch target.
+ * Policy knobs (`slowRequests`, `httpAbortedRequests`, `httpClientErrorRequests`,
+ * `autoAttributeRequests`) are stored on shared `__stJourney` so MFEs inherit host settings.
+ * No-ops when `isJourneyEnabled()` is false (host default or force flag).
+ * Never throws: missing/invalid config and failures soft-skip (warn / error to console).
  */
 export function configureJourney(config: JourneyConfig): void {
-    if (config.requestTimeouts !== undefined) {
-        moduleRuntime.setRequestTimeouts({
-            ...config.requestTimeouts,
-            endpoints: sortEndpointsByLongestMatch(config.requestTimeouts.endpoints),
-        });
-    }
-    if (config.sinks !== undefined) {
-        moduleRuntime.setSinks(config.sinks);
-    }
-    if (config.axios !== undefined) {
-        instrumentAxios(config.axios);
-    }
-    if (config.fetch !== undefined) {
-        instrumentFetch(config.fetch === true ? {} : config.fetch);
+    if (config == null || typeof config !== 'object') {
+        // eslint-disable-next-line no-console -- soft-skip missing host config
+        console.warn('[journey] configureJourney: skipped — missing');
+        return;
     }
-    if (config.jquery !== undefined) {
-        instrumentJquery(config.jquery);
+    if (!isJourneyEnabled()) {
+        // eslint-disable-next-line no-console -- soft-skip when host default and force are off
+        console.warn(
+            '[journey] configureJourney: skipped — disabled (call setJourneyDefaultEnabled(true) or __stJourney.enable(), then configureJourney again / reload)'
+        );
+        return;
     }
-    if (config.exposeAppJourney) {
-        exposeAppJourney(config.exposeAppJourney === true ? undefined : config.exposeAppJourney);
+
+    try {
+        const overlay: {
+            slowRequests?: SlowRequestConfig;
+            httpAbortedRequests?: RequestPolicyConfig;
+            httpClientErrorRequests?: RequestPolicyConfig;
+            autoAttributeRequests?: boolean;
+        } = {};
+
+        const policyPatch: Parameters<typeof seedSharedPolicies>[0] = {};
+        let hasPolicyKnob = false;
+
+        if (config.slowRequests !== undefined) {
+            const sorted = {
+                ...config.slowRequests,
+                endpoints: sortEndpointsByLongestMatch(config.slowRequests.endpoints),
+            };
+            policyPatch.slowRequests = sorted;
+            policyPatch.slowRequestsConfigured = true;
+            overlay.slowRequests = sorted;
+            hasPolicyKnob = true;
+        }
+        if (config.httpAbortedRequests !== undefined) {
+            policyPatch.httpAbortedRequests = config.httpAbortedRequests;
+            overlay.httpAbortedRequests = config.httpAbortedRequests;
+            hasPolicyKnob = true;
+        }
+        if (config.httpClientErrorRequests !== undefined) {
+            policyPatch.httpClientErrorRequests = config.httpClientErrorRequests;
+            overlay.httpClientErrorRequests = config.httpClientErrorRequests;
+            hasPolicyKnob = true;
+        }
+        if (config.autoAttributeRequests !== undefined) {
+            policyPatch.autoAttributeRequests = config.autoAttributeRequests;
+            overlay.autoAttributeRequests = config.autoAttributeRequests;
+            hasPolicyKnob = true;
+        }
+
+        if (hasPolicyKnob) {
+            if (!areSharedPoliciesLocked()) {
+                seedSharedPolicies(policyPatch);
+            }
+            moduleRuntime.setPolicyOverlay(overlay);
+        }
+        if (config.maxSteps !== undefined) {
+            moduleRuntime.setMaxSteps(config.maxSteps);
+        }
+        if (config.defaultJourneyIdleMs !== undefined) {
+            moduleRuntime.setDefaultJourneyIdleMs(config.defaultJourneyIdleMs);
+        }
+        if (config.sinks !== undefined) {
+            if (!moduleRuntime.trySetConfiguredSinks(config.sinks)) {
+                // eslint-disable-next-line no-console -- first-writer sinks
+                console.warn(
+                    '[journey] configureJourney: sinks already set on this runtime — ignoring'
+                );
+            }
+        }
+
+        const wiringTransport =
+            config.axios !== undefined ||
+            config.fetch !== undefined ||
+            (config.jquery !== undefined && config.jquery !== false);
+        if (wiringTransport) {
+            warnIfSlowRequestsUnset();
+        }
+
+        if (config.axios !== undefined) {
+            instrumentAxios(config.axios);
+        }
+        if (config.fetch !== undefined) {
+            instrumentFetch(config.fetch === true ? {} : config.fetch);
+        }
+        if (config.jquery === true) {
+            instrumentJquery(resolveGlobalJquery());
+        } else if (config.jquery !== undefined && config.jquery !== false) {
+            instrumentJquery(config.jquery);
+        }
+        if (config.exposeAppJourney) {
+            exposeAppJourney(
+                config.exposeAppJourney === true ? undefined : config.exposeAppJourney
+            );
+        }
+    } catch (err) {
+        // eslint-disable-next-line no-console -- soft-fail host wiring
+        console.error('[journey] configureJourney failed', err);
     }
 }
 
 /**
- * @internal Read the module runtime's app-wide request timeout config.
- * Prefer `configureJourney({ requestTimeouts })` to set thresholds. Test / introspection only.
+ * @internal Read the module runtime's app-wide slow-request config.
+ * Prefer `configureJourney({ slowRequests })` to set thresholds. Test / introspection only.
  */
-export function getRequestTimeouts(): AppRequestTimeouts {
-    return moduleRuntime.getRequestTimeouts();
+export function getSlowRequests(): SlowRequestConfig {
+    return getSharedSlowRequests() ?? moduleRuntime.getSlowRequests();
 }

package/src/core/abort-error.ts

@@ -0,0 +1,24 @@
+export function isAbortError(error: unknown): boolean {
+    if (error == null || typeof error !== 'object') {
+        return false;
+    }
+    const err = error as { name?: string; code?: string | number };
+    if (err.name === 'AbortError' || err.name === 'CanceledError') {
+        return true;
+    }
+    return err.code === 'ERR_CANCELED';
+}
+
+/** Axios cancel token, CanceledError, AbortError, or ERR_CANCELED. */
+export function isCanceledError(error: unknown): boolean {
+    if (isAbortError(error)) {
+        return true;
+    }
+    if (error == null || typeof error !== 'object') {
+        return false;
+    }
+    /* eslint-disable @typescript-eslint/naming-convention -- axios Cancel token wire format */
+    const err = error as { __CANCEL__?: boolean };
+    return err.__CANCEL__ === true;
+    /* eslint-enable @typescript-eslint/naming-convention */
+}

package/src/core/api.ts

@@ -1,40 +1,87 @@
-import { moduleRuntime } from './runtime';
+import { moduleRuntime, resolveJourneyEngine } from './runtime';
+import { adoptJourneyStepStamp, JourneyStepStamp } from './step-tag';
 import type {
     JourneyDef,
     JourneyHandle,
     JourneyStepOptions,
-    JourneyStepRef,
     JourneyStepTarget,
     StepHandle,
+    StepRecord,
     TagValue,
 } from './types';
 
+let ambientStamp: JourneyStepStamp | null = null;
+let ambientStep: StepRecord | null = null;
+
 /**
- * Active step for soft-ambient HTTP attribution, or null when 0 or 2+ steps are in flight
- * app-wide. Untagged traffic is attributed to that lone step even if unrelated — prefer
- * `step.tag()` when the page has background instrumented requests. Adapters call this when
- * a request has no explicit stamp.
+ * Unique in-flight step as a stamp-ready {@link JourneyStepStamp}, or null when
+ * auto-attribute is disabled, or when 0 or 2+ steps are in flight app-wide.
+ * Ambient stamps never carry `score` or `ignore`. Untagged traffic is attributed
+ * to that lone step even if unrelated — prefer `step.stamp()` when the page has
+ * background instrumented requests. Disable via
+ * `configureJourney({ autoAttributeRequests: false })`.
  */
-export function activeJourneyStep(): JourneyStepRef | null {
-    return moduleRuntime.activeJourneyStep();
+export function singleInFlightJourneyStep(): JourneyStepStamp | null {
+    if (ambientStep?.journey.closed) {
+        ambientStep = null;
+        ambientStamp = null;
+    }
+    const activeStep = moduleRuntime.activeJourneyStep();
+    if (!activeStep) {
+        ambientStamp = null;
+        ambientStep = null;
+        return null;
+    }
+    if (ambientStep === activeStep && ambientStamp) {
+        return ambientStamp;
+    }
+    ambientStep = activeStep;
+    ambientStamp = new JourneyStepStamp(activeStep);
+    return ambientStamp;
+}
+
+/** @internal Clear cached ambient stamp when runtime state changes. */
+export function invalidateAmbientStamp(step?: StepRecord): void {
+    if (!step || step === ambientStep) {
+        ambientStamp = null;
+        ambientStep = null;
+    }
+}
+
+/**
+ * Prefer an explicit `step.stamp()` value; else the ambient in-flight stamp.
+ * Same-realm stamps are returned as-is (identity + score + ignore). Branded
+ * foreign copies are adopted into a local stamp. Raw StepRecords are not stamps.
+ */
+export function resolveStamp(explicit?: unknown): JourneyStepStamp | undefined {
+    const fromExplicit = adoptJourneyStepStamp(explicit);
+    if (fromExplicit) {
+        return fromExplicit;
+    }
+    return singleInFlightJourneyStep() ?? undefined;
 }
 
 /**
  * Record a finished backend request against a captured step.
  * 5xx / network / slow (over threshold) mark Bad; 4xx is not counted. Fail-fast on breach.
+ * @internal Prefer {@link onHttpComplete} from adapters.
  */
 export function reportBackendRequest(
-    step: JourneyStepRef | undefined,
+    step: StepRecord | undefined,
     status: number | undefined,
     durationMs: number,
     requestKey: string
 ): void {
-    moduleRuntime.reportBackendRequest(step, status, durationMs, requestKey);
+    if (!step?.journey) {
+        return;
+    }
+    resolveJourneyEngine(step.journey).reportBackendRequest(step, status, durationMs, requestKey);
 }
 
 /**
  * Run one step of a named journey. Runs untraced (noop handle) when no matching journey is open.
- * `journey` may be a name, null, or an ordered candidate list.
+ * `journey` may be a name, null, an ordered candidate list, a def, or a handle.
+ * A def or handle auto-starts when that journey is not already open; a bare name does not.
  * Prefer `defineJourney(...).step` when you own the journey config.
  */
 export async function journeyStep<T>(
@@ -53,7 +100,10 @@ export function setJourneyTags(name: string | null, tags: Record<string, TagValu
 
 /** Mark a named journey Bad for a custom reason (fail-fast). Prefer `handle.fail`. */
 export function failJourney(name: string, reason: string): void {
-    moduleRuntime.failJourney(name, reason);
+    const journey = moduleRuntime.getOpenJourney(name);
+    if (journey) {
+        moduleRuntime.failJourney(journey, reason);
+    }
 }
 
 /** Successful end. Outcome stays Bad if a breach already occurred. No-op when name is null. Prefer `handle.complete`. */
@@ -63,47 +113,47 @@ export function completeJourney(name: string | null, tags?: Record<string, TagVa
 
 /** User left before finishing. Stays Bad if a breach already occurred (breach-anchored). Prefer `handle.exclude`. */
 export function excludeJourney(name: string): void {
-    moduleRuntime.excludeJourney(name);
+    const journey = moduleRuntime.getOpenJourney(name);
+    if (journey) {
+        moduleRuntime.excludeJourney(journey);
+    }
 }
 
 /** Turn a journey config into a handle with bound lifecycle methods. Preferred public API. */
-export function defineJourney(def: JourneyDef): JourneyHandle {
-    const ensureStarted = () => {
-        if (!moduleRuntime.getOpenJourney(def.name)) {
-            moduleRuntime.startJourney(def);
-        }
-    };
-
-    const handle: JourneyHandle = {
-        ...def,
+export function defineJourney(config: JourneyDef): JourneyHandle {
+    return {
+        config,
         start(tags) {
-            moduleRuntime.startJourney(def);
+            moduleRuntime.startJourney(config);
             if (tags) {
-                moduleRuntime.setJourneyTags(def.name, tags);
+                moduleRuntime.setJourneyTags(config.name, tags);
             }
         },
         step(stepName, fn, opts) {
-            ensureStarted();
-            return journeyStep(def.name, stepName, fn, opts);
+            if (!moduleRuntime.getOpenJourney(config.name)) {
+                moduleRuntime.startJourney(config);
+            }
+            return journeyStep(config.name, stepName, fn, opts);
         },
         async mountStep(stepName, fn, opts) {
             // Defer so a parent <JourneyScope> opens first (child effects run before parent).
             await Promise.resolve();
-            ensureStarted();
-            return journeyStep(def.name, stepName, fn, opts);
+            if (!moduleRuntime.getOpenJourney(config.name)) {
+                moduleRuntime.startJourney(config);
+            }
+            return journeyStep(config.name, stepName, fn, opts);
         },
         complete(tags) {
-            completeJourney(def.name, tags);
+            completeJourney(config.name, tags);
         },
         fail(reason) {
-            failJourney(def.name, reason);
+            failJourney(config.name, reason);
         },
         exclude() {
-            excludeJourney(def.name);
+            excludeJourney(config.name);
         },
         setTags(tags) {
-            setJourneyTags(def.name, tags);
+            setJourneyTags(config.name, tags);
         },
     };
-    return handle;
 }

package/src/core/endpoint-policy.ts

@@ -1,3 +1,5 @@
+import type { JourneyState } from './types';
+
 /** Per-endpoint request policy (app-wide or per-journey). Longest matching prefix wins. */
 export interface EndpointPolicy {
     /**
@@ -7,20 +9,25 @@ export interface EndpointPolicy {
      * `match` already supplies the boundary.
      */
     match: string;
-    /** Custom slow-request threshold in ms; omit / 0 falls through. */
-    timeoutMs?: number;
-    /** When true, errors and slow responses never mark the journey Bad. */
+    /** Custom slow-request threshold in ms; omit to fall through. `0` disables latency scoring for this prefix. */
+    slowRequestMs?: number;
+    /** When true, this endpoint never changes the journey verdict (errors, latency, aborts, 4xx). */
     ignore?: boolean;
 }
 
 /** App-wide slow-request threshold fallback (not an axios abort). */
-export interface AppRequestTimeouts {
+export interface SlowRequestConfig {
     /** Fallback threshold when no endpoint or journey override applies. */
     defaultMs: number;
     /** App-wide endpoint overrides; journey-specific ones belong on JourneyDef.endpoints. */
     endpoints?: readonly EndpointPolicy[];
 }
 
+export interface ResolvedEndpointPolicy {
+    ignore: boolean;
+    slowRequestMs: number;
+}
+
 /** Copy sorted longest-match-first so lookup can return on the first hit. */
 export function sortEndpointsByLongestMatch(
     endpoints: readonly EndpointPolicy[] | undefined
@@ -64,3 +71,38 @@ export function longestEndpointMatch(
     }
     return undefined;
 }
+
+/**
+ * Resolve ignore + latency threshold with longest-prefix matching.
+ * Journey overrides win over app defaults for slow thresholds.
+ */
+export function resolveEndpointPolicy(
+    journey: JourneyState,
+    appSlow: SlowRequestConfig,
+    requestKey: string
+): ResolvedEndpointPolicy {
+    const own = longestEndpointMatch(journey.endpoints, requestKey);
+    if (own?.ignore === true) {
+        return { ignore: true, slowRequestMs: 0 };
+    }
+
+    const app = longestEndpointMatch(appSlow.endpoints, requestKey);
+    if (own) {
+        return {
+            ignore: false,
+            slowRequestMs:
+                own.slowRequestMs ??
+                app?.slowRequestMs ??
+                journey.slowRequestMs ??
+                appSlow.defaultMs,
+        };
+    }
+    if (app?.ignore === true) {
+        return { ignore: true, slowRequestMs: 0 };
+    }
+
+    return {
+        ignore: false,
+        slowRequestMs: app?.slowRequestMs ?? journey.slowRequestMs ?? appSlow.defaultMs,
+    };
+}

package/src/core/index.ts

@@ -1,17 +1,18 @@
 /** Core barrel — public free helpers, handles, and types. Engine lives in `./runtime`. */
 
 export {
-    activeJourneyStep,
     completeJourney,
     defineJourney,
     excludeJourney,
     failJourney,
     journeyStep,
     reportBackendRequest,
+    resolveStamp,
     setJourneyTags,
+    singleInFlightJourneyStep,
 } from './api';
 export {
-    // @internal — accidentally public via package index; not a supported consumer API.
+    // @internal Test helper — not a supported consumer API.
     resetJourney,
 } from './runtime';
 export type {
@@ -22,9 +23,16 @@ export type {
     JourneySink,
     JourneyStepEvent,
     JourneyStepOptions,
-    JourneyStepRef,
     JourneyStepTarget,
     StepHandle,
     TagValue,
 } from './types';
-export { JourneyStepTag, resolveJourneyStep } from './step-tag';
+export { JourneyStepStamp } from './step-tag';
+export type {
+    JourneyHttpPolicyContext,
+    JourneyHttpScore,
+    JourneyHttpScoreContext,
+    JourneyRequestPolicy,
+    JourneyStampOptions,
+    RequestPolicyConfig,
+} from './request-policy';