@servicetitan/journey 2.0.0 → 2.1.0

package/src/config.ts

@@ -1,10 +1,11 @@
-import { defaultRuntime } from './core/runtime';
-import { setJourneySinks, type JourneySink } from './core/registry';
+import { moduleRuntime } from './core/runtime';
+import type { JourneySink } from './core/types';
+import { installJourneyGlobal, registerJourneyRuntime } from './global';
 import {
     sortEndpointsByLongestMatch,
     type AppRequestTimeouts,
     type EndpointPolicy,
-} from './endpoint-policy';
+} from './core/endpoint-policy';
 import { instrumentAxios, type AxiosLikeInstance } from './integrations/axios';
 import { instrumentFetch, type InstrumentFetchOptions } from './integrations/fetch';
 import {
@@ -13,9 +14,9 @@ import {
     type JqueryStatic,
     type WindowWithAppJourney,
 } from './integrations/jquery';
+import { sendToConsole } from './sinks/console';
 import { sendToDatadog } from './sinks/datadog';
 
-export { longestEndpointMatch, sortEndpointsByLongestMatch } from './endpoint-policy';
 export type { AppRequestTimeouts, EndpointPolicy };
 
 /** Optional app-wide / per-bundle configuration. */
@@ -25,7 +26,8 @@ export interface JourneyConfig {
     /**
      * Replace the sink list used when a journey finishes.
      * Only applied when provided — omit to leave the current list unchanged.
-     * Package default is `[sendToDatadog]`; pass `[]` to disable emission.
+     * Package default is `[sendToDatadog, sendToConsole]`; pass `[]` to disable emission.
+     * `sendToConsole` is a no-op unless `localStorage['st:journey:debug'] === 'true'`.
      */
     sinks?: readonly JourneySink[];
     /**
@@ -48,11 +50,13 @@ export interface JourneyConfig {
 }
 
 /*
- * Default emission target. Kept as a module side effect so any import of this file
- * (see index.ts `import './config'`) installs Datadog. configureJourney only replaces
- * sinks when `sinks` is passed explicitly.
+ * Default emission targets + `__stJourney` bag. Kept as a module side effect so any import
+ * of this file (see index.ts `import './config'`) installs Datadog, console, and
+ * `__stJourney`. configureJourney only replaces sinks when `sinks` is passed explicitly.
  */
-setJourneySinks([sendToDatadog]);
+moduleRuntime.setSinks([sendToDatadog, sendToConsole]);
+installJourneyGlobal();
+registerJourneyRuntime(moduleRuntime);
 
 /**
  * Apply bundle options: request thresholds, sinks, and/or HTTP / legacy wiring.
@@ -60,13 +64,13 @@ setJourneySinks([sendToDatadog]);
  */
 export function configureJourney(config: JourneyConfig): void {
     if (config.requestTimeouts !== undefined) {
-        defaultRuntime.setRequestTimeouts({
+        moduleRuntime.setRequestTimeouts({
             ...config.requestTimeouts,
             endpoints: sortEndpointsByLongestMatch(config.requestTimeouts.endpoints),
         });
     }
     if (config.sinks !== undefined) {
-        setJourneySinks(config.sinks);
+        moduleRuntime.setSinks(config.sinks);
     }
     if (config.axios !== undefined) {
         instrumentAxios(config.axios);
@@ -82,6 +86,10 @@ export function configureJourney(config: JourneyConfig): void {
     }
 }
 
+/**
+ * @internal Read the module runtime's app-wide request timeout config.
+ * Prefer `configureJourney({ requestTimeouts })` to set thresholds. Test / introspection only.
+ */
 export function getRequestTimeouts(): AppRequestTimeouts {
-    return defaultRuntime.getRequestTimeouts();
+    return moduleRuntime.getRequestTimeouts();
 }

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

@@ -1,10 +1,7 @@
-import { defaultRuntime } from './runtime';
+import { moduleRuntime } from './runtime';
 import type {
     JourneyDef,
-    JourneyEvent,
     JourneyHandle,
-    JourneySink,
-    JourneyState,
     JourneyStepOptions,
     JourneyStepRef,
     JourneyStepTarget,
@@ -12,18 +9,6 @@ import type {
     TagValue,
 } from './types';
 
-export type { JourneyHandle, JourneySink };
-
-/** Look up an open journey by name. */
-export function getOpenJourney(name: string): JourneyState | undefined {
-    return defaultRuntime.getOpenJourney(name);
-}
-
-/** First open journey among `names` (order preserved), or null. */
-export function firstOpenJourney(names: readonly string[]): string | null {
-    return defaultRuntime.firstOpenJourney(names);
-}
-
 /**
  * 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
@@ -31,7 +16,7 @@ export function firstOpenJourney(names: readonly string[]): string | null {
  * a request has no explicit stamp.
  */
 export function activeJourneyStep(): JourneyStepRef | null {
-    return defaultRuntime.activeJourneyStep();
+    return moduleRuntime.activeJourneyStep();
 }
 
 /**
@@ -44,7 +29,7 @@ export function reportBackendRequest(
     durationMs: number,
     requestKey: string
 ): void {
-    defaultRuntime.reportBackendRequest(step, status, durationMs, requestKey);
+    moduleRuntime.reportBackendRequest(step, status, durationMs, requestKey);
 }
 
 /**
@@ -58,81 +43,43 @@ export async function journeyStep<T>(
     fn: (step: StepHandle) => T | Promise<T>,
     opts?: JourneyStepOptions
 ): Promise<T> {
-    return defaultRuntime.journeyStep(journey, stepName, fn, opts);
-}
-
-/**
- * journeyStep deferred by one microtask so a parent `<JourneyScope>` opens first
- * (React runs child mount effects before parent). Use for mount-effect steps only.
- */
-export async function journeyMountStep<T>(
-    journey: JourneyStepTarget,
-    stepName: string,
-    fn: (step: StepHandle) => T | Promise<T>,
-    opts?: JourneyStepOptions
-): Promise<T> {
-    return defaultRuntime.journeyMountStep(journey, stepName, fn, opts);
-}
-
-/** Replace the sink list (e.g. host bootstrap or tests). Pass `[]` to disable emission. */
-export function setJourneySinks(next: readonly JourneySink[]): void {
-    defaultRuntime.setSinks(next);
-}
-
-/** Append a sink alongside the current ones. */
-export function addJourneySink(sink: JourneySink): void {
-    defaultRuntime.addSink(sink);
-}
-
-/** Emit a terminal journey event to every configured sink. */
-export function emitJourneyEvent(payload: JourneyEvent): void {
-    defaultRuntime.emit(payload);
+    return moduleRuntime.journeyStep(journey, stepName, fn, opts);
 }
 
 /** Merge custom tags onto an open journey. No-op if not open. Prefer `handle.setTags`. */
 export function setJourneyTags(name: string | null, tags: Record<string, TagValue>): void {
-    defaultRuntime.setJourneyTags(name, tags);
-}
-
-/** Begin a journey. Restarts (closes) an already-open journey of the same name. */
-export function startJourney(def: JourneyDef): void {
-    defaultRuntime.startJourney(def);
-}
-
-/** Fail-fast: record reason and emit immediately. Idempotent via `closed`. */
-export function failJourneyNow(journey: JourneyState, reason: string): void {
-    defaultRuntime.failJourneyNow(journey, reason);
+    moduleRuntime.setJourneyTags(name, tags);
 }
 
 /** Mark a named journey Bad for a custom reason (fail-fast). Prefer `handle.fail`. */
 export function failJourney(name: string, reason: string): void {
-    defaultRuntime.failJourney(name, reason);
+    moduleRuntime.failJourney(name, reason);
 }
 
 /** Successful end. Outcome stays Bad if a breach already occurred. No-op when name is null. Prefer `handle.complete`. */
 export function completeJourney(name: string | null, tags?: Record<string, TagValue>): void {
-    defaultRuntime.completeJourney(name, tags);
+    moduleRuntime.completeJourney(name, tags);
 }
 
 /** User left before finishing. Stays Bad if a breach already occurred (breach-anchored). Prefer `handle.exclude`. */
 export function excludeJourney(name: string): void {
-    defaultRuntime.excludeJourney(name);
+    moduleRuntime.excludeJourney(name);
 }
 
 /** Turn a journey config into a handle with bound lifecycle methods. Preferred public API. */
 export function defineJourney(def: JourneyDef): JourneyHandle {
     const ensureStarted = () => {
-        if (!getOpenJourney(def.name)) {
-            startJourney(def);
+        if (!moduleRuntime.getOpenJourney(def.name)) {
+            moduleRuntime.startJourney(def);
         }
     };
 
     const handle: JourneyHandle = {
         ...def,
         start(tags) {
-            startJourney(def);
+            moduleRuntime.startJourney(def);
             if (tags) {
-                setJourneyTags(def.name, tags);
+                moduleRuntime.setJourneyTags(def.name, tags);
             }
         },
         step(stepName, fn, opts) {

package/src/core/index.ts

@@ -1,34 +1,25 @@
-/** Core engine barrel — free helpers over the default runtime, plus handles and types. */
+/** Core barrel — public free helpers, handles, and types. Engine lives in `./runtime`. */
 
 export {
     activeJourneyStep,
-    addJourneySink,
     completeJourney,
     defineJourney,
-    emitJourneyEvent,
     excludeJourney,
     failJourney,
-    firstOpenJourney,
-    journeyMountStep,
     journeyStep,
     reportBackendRequest,
-    setJourneySinks,
     setJourneyTags,
-    startJourney,
-    type JourneyHandle,
-    type JourneySink,
-} from './registry';
+} from './api';
 export {
-    createJourneyRuntime,
-    defaultRuntime,
+    // @internal — accidentally public via package index; not a supported consumer API.
     resetJourney,
-    type JourneyRuntime,
-    type JourneyRuntimeOptions,
 } from './runtime';
 export type {
     JourneyDef,
     JourneyEvent,
+    JourneyHandle,
     JourneyNameLike,
+    JourneySink,
     JourneyStepEvent,
     JourneyStepOptions,
     JourneyStepRef,

package/src/core/runtime.ts

@@ -2,7 +2,7 @@ import {
     longestEndpointMatch,
     sortEndpointsByLongestMatch,
     type AppRequestTimeouts,
-} from '../endpoint-policy';
+} from './endpoint-policy';
 import { JourneyStepTag } from './step-tag';
 import type {
     JourneyDef,
@@ -36,16 +36,37 @@ function toName(target: string | { readonly name: string }): string {
 
 /** @internal Private — not part of the public package API. */
 export interface JourneyRuntimeOptions {
-    /** Initial sinks. Defaults to `[]` — package bootstrap installs Datadog on the default runtime. */
+    /** Initial sinks. Defaults to `[]` — package bootstrap installs Datadog on the module runtime. */
     sinks?: readonly JourneySink[];
     requestTimeouts?: AppRequestTimeouts;
 }
 
+/** @internal Read-only snapshot for DevTools (`__stJourney.getDebugState`; empty unless debugging). */
+export interface JourneyRuntimeDebugSnapshot {
+    openJourneys: readonly {
+        name: string;
+        team: string;
+        group: string;
+        service: string;
+        verdict: Outcome;
+        reason: string | null;
+        tags: Record<string, TagValue>;
+        stepsInFlight: readonly string[];
+        steps: readonly {
+            name: string;
+            outcome: 'good' | 'bad';
+            durationMs: number;
+            reason?: string;
+        }[];
+    }[];
+    activeStep: { journey: string; name: string } | null;
+}
+
 /**
  * @internal Private — not part of the public package API.
  * Isolated journey engine (open journeys, ambient steps, sinks, request thresholds).
  * App code should keep using free helpers (`defineJourney`, `journeyStep`, …) — they
- * bind to the process default runtime. Prefer `resetJourney()` in tests.
+ * bind to the module runtime. Prefer `resetJourney()` in tests.
  */
 export interface JourneyRuntime {
     getRequestTimeouts(): AppRequestTimeouts;
@@ -56,6 +77,8 @@ export interface JourneyRuntime {
     emit(payload: JourneyEvent): void;
 
     getOpenJourney(name: string): JourneyState | undefined;
+    /** @internal DevTools snapshot of open journeys / ambient step. */
+    getDebugSnapshot(): JourneyRuntimeDebugSnapshot;
     firstOpenJourney(names: readonly string[]): string | null;
     setJourneyTags(name: string | null, tags: Record<string, TagValue>): void;
     startJourney(def: JourneyDef): void;
@@ -278,6 +301,29 @@ export function createJourneyRuntime(options: JourneyRuntimeOptions = {}): Journ
             return journeys.get(name);
         },
 
+        getDebugSnapshot() {
+            const active = api.activeJourneyStep();
+            return {
+                openJourneys: [...journeys.values()].map(journey => ({
+                    name: journey.name,
+                    team: journey.team,
+                    group: journey.group,
+                    service: journey.service,
+                    verdict: journey.verdict,
+                    reason: journey.reason,
+                    tags: { ...journey.tags },
+                    stepsInFlight: getInFlightSteps(journey).map(step => step.name),
+                    steps: journey.steps.map(step => ({
+                        name: step.name,
+                        outcome: step.outcome,
+                        durationMs: step.durationMs,
+                        ...(step.reason ? { reason: step.reason } : {}),
+                    })),
+                })),
+                activeStep: active ? { journey: active.journey.name, name: active.name } : null,
+            };
+        },
+
         firstOpenJourney(names) {
             for (const name of names) {
                 if (journeys.has(name)) {
@@ -476,14 +522,17 @@ export function createJourneyRuntime(options: JourneyRuntimeOptions = {}): Journ
 
 /**
  * @internal Private — not part of the public package API.
- * Process-wide engine used by free helpers. App code does not need to touch this.
+ * 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 defaultRuntime: JourneyRuntime = createJourneyRuntime();
+export const moduleRuntime: JourneyRuntime = createJourneyRuntime();
 
 /**
- * Reset the default engine (open journeys, ambient steps, sinks, request thresholds).
+ * @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).
  * Intended for tests — call in `beforeEach` / `afterEach` instead of manual cleanup.
  */
 export function resetJourney(options?: JourneyRuntimeOptions): void {
-    defaultRuntime.reset(options);
+    moduleRuntime.reset(options);
 }

package/src/core/step-tag.ts

@@ -10,6 +10,15 @@ import type { JourneyStepRef, StepRecord } from './types';
  */
 export class JourneyStepTag {
     constructor(readonly step: StepRecord) {}
+
+    /**
+     * Circular by design (`step.journey.steps → step`) for mergeConfig/deep-merge
+     * safety. Prevent accidental `JSON.stringify` (e.g. AxiosError.toJSON() includes
+     * config by reference) elsewhere in the app from throwing "circular structure".
+     */
+    toJSON(): string {
+        return '[JourneyStepTag]';
+    }
 }
 
 /** Unwrap `step.tag().journeyStep` or a JourneyStepTag / StepRecord stamp. */

package/src/core/types.ts

@@ -1,4 +1,4 @@
-import type { EndpointPolicy } from '../endpoint-policy';
+import type { EndpointPolicy } from './endpoint-policy';
 
 /** Arbitrary tag values a developer can attach. */
 export type TagValue = string | number | boolean;
@@ -63,6 +63,7 @@ export interface JourneyStepOptions {
     timeoutMs?: number;
 }
 
+/** @internal Engine open-journey record — not part of the supported public API. */
 export interface JourneyState {
     name: string;
     team: string;
@@ -87,6 +88,7 @@ export interface JourneyState {
     closed: boolean;
 }
 
+/** @internal Engine in-flight / completed step record — not part of the supported public API. */
 export interface StepRecord {
     name: string;
     startedAt: number;

package/src/global.ts

@@ -0,0 +1,196 @@
+import type { JourneyRuntime, JourneyRuntimeDebugSnapshot } from './core/runtime';
+
+/** Force-enable journey host wiring outside go* hosts (`__stJourney.enable()`). */
+export const JOURNEY_ENABLED_STORAGE_KEY = 'st:journey:enabled';
+
+/** Opt-in journey console logging (`__stJourney.enableDebugging()`). */
+export const JOURNEY_DEBUG_STORAGE_KEY = 'st:journey:debug';
+
+/** @internal Shared cross-bundle bag on globalThis (`rum` fallback + DevTools helpers). */
+export const ST_JOURNEY_GLOBAL_KEY = '__stJourney';
+
+export interface JourneyDebugRuntimeEntry extends JourneyRuntimeDebugSnapshot {
+    id: string;
+}
+
+export interface JourneyDebugState {
+    /** Force-enable flag (`st:journey:enabled`). */
+    enabled: boolean;
+    /** Console-logging flag (`st:journey:debug`). */
+    debug: boolean;
+    hasRum: boolean;
+    runtimes: JourneyDebugRuntimeEntry[];
+}
+
+/**
+ * @internal Cross-bundle surface on `globalThis.__stJourney`.
+ * Prefer importing `isJourneyEnabled` / `isJourneyDebugEnabled` from the package in app code.
+ */
+export interface StJourneyGlobal {
+    /**
+     * Fallback RUM instance from `setJourneyRum` when `globalThis.DD_RUM` is absent.
+     * Prefer `DD_RUM` (ST host: `datadogGuard`).
+     */
+    rum?: unknown;
+    enable(): void;
+    disable(): void;
+    isEnabled(): boolean;
+    enableDebugging(): void;
+    disableDebugging(): void;
+    isDebugEnabled(): boolean;
+    /**
+     * Open-journey snapshot for DevTools. Returns empty `runtimes` unless debugging
+     * is enabled (`enableDebugging()` / `st:journey:debug`).
+     */
+    getDebugState(): JourneyDebugState;
+}
+
+interface RuntimeRegistration {
+    id: string;
+    getSnapshot: () => JourneyRuntimeDebugSnapshot;
+}
+
+interface StJourneyGlobalInternal extends StJourneyGlobal {
+    /** @internal */
+    runtimeRegistrations: RuntimeRegistration[];
+}
+
+let runtimeSeq = 0;
+
+function readFlag(key: string): boolean {
+    try {
+        return globalThis.localStorage?.getItem(key) === 'true';
+    } catch {
+        return false;
+    }
+}
+
+function writeFlag(key: string, on: boolean): void {
+    try {
+        if (on) {
+            globalThis.localStorage?.setItem(key, 'true');
+        } else {
+            globalThis.localStorage?.removeItem(key);
+        }
+    } catch {
+        // ignore storage failures (privacy mode, non-browser)
+    }
+}
+
+/** True when `localStorage['st:journey:enabled'] === 'true'` (force-on outside go*). */
+export function isJourneyEnabled(): boolean {
+    return readFlag(JOURNEY_ENABLED_STORAGE_KEY);
+}
+
+/** Set the force-enable flag. Reload after calling from DevTools. */
+export function enableJourney(): void {
+    writeFlag(JOURNEY_ENABLED_STORAGE_KEY, true);
+}
+
+/** Clear the force-enable flag. Reload after calling from DevTools. */
+export function disableJourney(): void {
+    writeFlag(JOURNEY_ENABLED_STORAGE_KEY, false);
+}
+
+/** True when `localStorage['st:journey:debug'] === 'true'`. */
+export function isJourneyDebugEnabled(): boolean {
+    return readFlag(JOURNEY_DEBUG_STORAGE_KEY);
+}
+
+/** Set the console-debug flag. Reload after calling from DevTools. */
+export function enableJourneyDebugging(): void {
+    writeFlag(JOURNEY_DEBUG_STORAGE_KEY, true);
+}
+
+/** Clear the console-debug flag. Reload after calling from DevTools. */
+export function disableJourneyDebugging(): void {
+    writeFlag(JOURNEY_DEBUG_STORAGE_KEY, false);
+}
+
+function hasRum(): boolean {
+    return (
+        (globalThis as Record<string, unknown>).DD_RUM != null || getJourneyRumFallback() != null
+    );
+}
+
+function buildDebugState(runtimes: RuntimeRegistration[]): JourneyDebugState {
+    if (!isJourneyDebugEnabled()) {
+        return {
+            enabled: isJourneyEnabled(),
+            debug: false,
+            hasRum: hasRum(),
+            runtimes: [],
+        };
+    }
+
+    return {
+        enabled: isJourneyEnabled(),
+        debug: true,
+        hasRum: hasRum(),
+        runtimes: runtimes.map(entry => ({
+            id: entry.id,
+            ...entry.getSnapshot(),
+        })),
+    };
+}
+
+function ensureGlobal(): StJourneyGlobalInternal {
+    const g = globalThis as Record<string, unknown>;
+    const existing = g[ST_JOURNEY_GLOBAL_KEY] as StJourneyGlobalInternal | undefined;
+    // Reuse when a prior load already installed the full surface (incl. enable).
+    if (existing?.runtimeRegistrations && typeof existing.enable === 'function') {
+        return existing;
+    }
+
+    const runtimes: RuntimeRegistration[] = existing?.runtimeRegistrations ?? [];
+
+    const api: StJourneyGlobalInternal = {
+        rum: existing?.rum,
+        runtimeRegistrations: runtimes,
+        enable: enableJourney,
+        disable: disableJourney,
+        isEnabled: isJourneyEnabled,
+        enableDebugging: enableJourneyDebugging,
+        disableDebugging: disableJourneyDebugging,
+        isDebugEnabled: isJourneyDebugEnabled,
+        getDebugState() {
+            return buildDebugState(api.runtimeRegistrations);
+        },
+    };
+
+    g[ST_JOURNEY_GLOBAL_KEY] = api;
+    return api;
+}
+
+/**
+ * @internal Register this bundle's module runtime on `__stJourney` so DevTools can
+ * list every host/MFE engine copy on the page.
+ */
+export function registerJourneyRuntime(runtime: JourneyRuntime): void {
+    const globalApi = ensureGlobal();
+    const id = `runtime-${++runtimeSeq}`;
+    globalApi.runtimeRegistrations.push({
+        id,
+        getSnapshot: () => runtime.getDebugSnapshot(),
+    });
+}
+
+/** @internal Ensure `__stJourney` exists (idempotent). */
+export function installJourneyGlobal(): void {
+    ensureGlobal();
+}
+
+/**
+ * @internal Store a fallback RUM instance on `__stJourney.rum` when `DD_RUM` is absent.
+ * Used by `setJourneyRum`.
+ */
+export function setJourneyRumFallback(rum: unknown): void {
+    ensureGlobal().rum = rum;
+}
+
+/** @internal Read `__stJourney.rum` (setJourneyRum fallback). */
+export function getJourneyRumFallback(): unknown {
+    const existing = (globalThis as Record<string, unknown>)[ST_JOURNEY_GLOBAL_KEY] as
+        StJourneyGlobal | undefined;
+    return existing?.rum;
+}

package/src/index.ts

@@ -6,17 +6,18 @@
 import './config';
 
 export {
-    // Custom transport adapters only.
-    activeJourneyStep,
-    // Prefer defineJourney(...).complete/fail/… — free helpers for name-from-context call sites.
-    completeJourney,
+    // Preferred app API.
     defineJourney,
+    // Name-string lifecycle (prefer handle methods when you own the journey).
+    completeJourney,
     excludeJourney,
     failJourney,
     journeyStep,
+    setJourneyTags,
+    // Custom transport adapters / request attribution.
+    activeJourneyStep,
     reportBackendRequest,
     resolveJourneyStep,
-    setJourneyTags,
     JourneyStepTag,
     type JourneyDef,
     type JourneyHandle,
@@ -36,14 +37,26 @@ export {
 
 export type { JourneySink } from './core';
 
-/** Test helper — clears open journeys / ambient steps on the default engine. */
+/**
+ * @internal Accidentally exported — removing it is a breaking change, so it stays
+ * for compatibility. Not part of the supported public API. Test helper only.
+ */
 export { resetJourney } from './core';
 
 export { instrumentAxios } from './integrations/axios';
 export { instrumentFetch } from './integrations/fetch';
 export { exposeAppJourney, instrumentJquery } from './integrations/jquery';
 export { requestKey, type JourneyTimedMeta } from './integrations/request-key';
-export { sendToDatadog, setJourneyRum } from './sinks/datadog';
+export {
+    disableJourney,
+    disableJourneyDebugging,
+    enableJourney,
+    enableJourneyDebugging,
+    isJourneyDebugEnabled,
+    isJourneyEnabled,
+} from './global';
+export { sendToConsole } from './sinks/console';
+export { normalizeTagValue, sendToDatadog, setJourneyRum } from './sinks/datadog';
 
 export type { JourneyEvent, JourneyStepEvent, TagValue } from './core';
 

package/src/integrations/fetch.ts

@@ -2,10 +2,10 @@ import { activeJourneyStep, reportBackendRequest, resolveJourneyStep } from '../
 import { requestKey, type JourneyTimedMeta } from './request-key';
 
 /** Minimal structural fetch shape. */
-export type FetchLike = (input: any, init?: any) => Promise<{ status: number }>;
+type FetchLike = (input: any, init?: any) => Promise<{ status: number }>;
 
 /** Holder of a `fetch` property — globalThis by default, or a scoped object. */
-export interface FetchTarget {
+interface FetchTarget {
     fetch: FetchLike;
 }