@walkeros/core 4.0.0-next-1777463920154 → 4.0.0

package/dist/index.d.mts

@@ -62,7 +62,7 @@ type ValueType = string | ValueConfig;
 interface ValueConfig {
     condition?: Condition;
     consent?: Consent;
-    fn?: Fn$3;
+    fn?: Fn$4;
     key?: string;
     loop?: Loop;
     map?: Map;
@@ -70,18 +70,21 @@ interface ValueConfig {
     validate?: Validate;
     value?: PropertyType;
 }
-type Condition = (value: DeepPartialEvent | unknown, mapping?: Value, collector?: Instance$6) => PromiseOrValue<boolean>;
-type Fn$3 = (value: DeepPartialEvent | unknown, mapping: Value, options: Options$1) => PromiseOrValue<Property | unknown>;
+interface Context$6 {
+    event: DeepPartialEvent;
+    /** The surrounding mapping config: a Value (value-level) or a Rule (rule-level). */
+    mapping: Value | Rule;
+    collector: Instance$6;
+    logger: Instance$4;
+    consent?: Consent;
+}
+type Fn$4 = (value: unknown, context: Context$6) => PromiseOrValue<Property | unknown>;
+type Condition = (value: unknown, context: Context$6) => PromiseOrValue<boolean>;
+type Validate = (value: unknown, context: Context$6) => PromiseOrValue<boolean>;
 type Loop = [Value, Value];
 type Map = {
     [key: string]: Value;
 };
-interface Options$1 {
-    consent?: Consent;
-    collector?: Instance$6;
-    props?: unknown;
-}
-type Validate = (value?: unknown) => PromiseOrValue<boolean>;
 
 type mapping_Condition = Condition;
 type mapping_Loop = Loop;
@@ -94,7 +97,7 @@ type mapping_ValueConfig = ValueConfig;
 type mapping_ValueType = ValueType;
 type mapping_Values = Values;
 declare namespace mapping {
-  export type { mapping_Condition as Condition, Config$7 as Config, Data$1 as Data, Fn$3 as Fn, mapping_Loop as Loop, mapping_Map as Map, Options$1 as Options, Policy$1 as Policy, Result$2 as Result, mapping_Rule as Rule, mapping_Rules as Rules, mapping_Validate as Validate, mapping_Value as Value, mapping_ValueConfig as ValueConfig, mapping_ValueType as ValueType, mapping_Values as Values };
+  export type { mapping_Condition as Condition, Config$7 as Config, Context$6 as Context, Data$1 as Data, Fn$4 as Fn, mapping_Loop as Loop, mapping_Map as Map, Policy$1 as Policy, Result$2 as Result, mapping_Rule as Rule, mapping_Rules as Rules, mapping_Validate as Validate, mapping_Value as Value, mapping_ValueConfig as ValueConfig, mapping_ValueType as ValueType, mapping_Values as Values };
 }
 
 interface CacheRule {
@@ -277,7 +280,7 @@ interface CommandFn {
     (command: 'consent', consent: Consent): Promise<PushResult>;
     <T extends Types$4>(command: 'destination', destination: Init$3<T> | Instance$5<T>, config?: Config$5<T>): Promise<PushResult>;
     <K extends keyof Functions>(command: 'hook', name: K, hookFn: Functions[K]): Promise<PushResult>;
-    (command: 'on', type: Types$3, rules: SingleOrArray<Options>): Promise<PushResult>;
+    (command: 'on', type: Types$3, rules: SingleOrArray<Subscription>): Promise<PushResult>;
     (command: 'user', user: User): Promise<PushResult>;
     (command: 'run', runState?: {
         consent?: Consent;
@@ -563,14 +566,14 @@ interface EventFn<R = Promise<PushResult>> {
     (event: string): R;
     (event: string, data: Properties): R;
 }
-interface Fn$2<R = Promise<PushResult>, Config = unknown> extends EventFn<R>, WalkerCommands<R, Config> {
+interface Fn$3<R = Promise<PushResult>, Config = unknown> extends EventFn<R>, WalkerCommands<R, Config> {
 }
 interface WalkerCommands<R = Promise<PushResult>, Config = unknown> {
     (event: 'walker config', config: Partial<Config>): R;
     (event: 'walker consent', consent: Consent): R;
     <T extends Types$4>(event: 'walker destination', destination: Init$3<T> | Instance$5<T>, config?: Config$5<T>): R;
     <K extends keyof Functions>(event: 'walker hook', name: K, hookFn: Functions[K]): R;
-    (event: 'walker on', type: Types$3, rules: SingleOrArray<Options>): R;
+    (event: 'walker on', type: Types$3, rules: SingleOrArray<Subscription>): R;
     (event: 'walker user', user: User): R;
     (event: 'walker run', runState: {
         consent?: Consent;
@@ -596,7 +599,7 @@ type elb_PushData<Config = unknown> = PushData<Config>;
 type elb_PushResult = PushResult;
 type elb_WalkerCommands<R = Promise<PushResult>, Config = unknown> = WalkerCommands<R, Config>;
 declare namespace elb {
-  export type { Event$1 as Event, elb_EventFn as EventFn, Fn$2 as Fn, elb_Layer as Layer, elb_PushData as PushData, elb_PushResult as PushResult, elb_WalkerCommands as WalkerCommands };
+  export type { Event$1 as Event, elb_EventFn as EventFn, Fn$3 as Fn, elb_Layer as Layer, elb_PushData as PushData, elb_PushResult as PushResult, elb_WalkerCommands as WalkerCommands };
 }
 
 /**
@@ -1299,83 +1302,95 @@ declare namespace logger {
   export { type Config$4 as Config, type logger_DefaultHandler as DefaultHandler, type logger_ErrorContext as ErrorContext, type logger_Factory as Factory, type logger_Handler as Handler, type Instance$4 as Instance, type logger_InternalConfig as InternalConfig, logger_Level as Level, type logger_LogContext as LogContext, type logger_LogFn as LogFn, type logger_ThrowFn as ThrowFn };
 }
 
+/** Collector state mapping for the `on` actions. */
 type Config$3 = {
-    config?: Array<GenericConfig>;
-    consent?: Array<ConsentConfig>;
-    custom?: Array<GenericConfig>;
-    globals?: Array<GenericConfig>;
-    ready?: Array<ReadyConfig>;
-    run?: Array<RunConfig>;
-    session?: Array<SessionConfig>;
-    user?: Array<UserConfig>;
+    config?: Array<GenericFn>;
+    consent?: Array<ConsentRule>;
+    custom?: Array<GenericFn>;
+    globals?: Array<GenericFn>;
+    ready?: Array<ReadyFn>;
+    run?: Array<RunFn>;
+    session?: Array<SessionFn>;
+    user?: Array<UserFn>;
 };
+/** Allow arbitrary string events via `(string & {})`. */
 type Types$3 = keyof Config$3 | (string & {});
-interface EventContextMap {
+/** Map each event type to its expected data payload type. */
+interface EventDataMap {
     config: Partial<Config$6>;
     consent: Consent;
     custom: Properties;
     globals: Properties;
-    ready: undefined;
-    run: undefined;
-    session: SessionData;
+    ready: void;
+    run: void;
+    session: SessionData | undefined;
     user: User;
 }
-type EventContext<T extends keyof EventContextMap> = EventContextMap[T];
-type AnyEventContext = EventContextMap[keyof EventContextMap];
+/** Extract the data type for a specific event. */
+type EventData<T extends keyof EventDataMap> = EventDataMap[T];
+/** Union of all possible data types. */
+type AnyEventData = EventDataMap[keyof EventDataMap];
+/**
+ * Context provided to every `on` callback.
+ * Same posture as Mapping.Context: collector + logger only;
+ * subscriptions are a collector-level concern, not a stage-level one.
+ */
 interface Context$4 {
-    consent?: Consent;
-    session?: unknown;
+    collector: Instance$6;
+    logger: Instance$4;
 }
-type Options = ConsentConfig | GenericConfig | ReadyConfig | RunConfig | SessionConfig | UserConfig;
-interface ConsentConfig {
+/** Unified subscription callback shape. */
+type Fn$2<TData = unknown> = (data: TData, context: Context$4) => PromiseOrValue<void>;
+/** Typed-data variants for readability and IntelliSense. All reduce to Fn<TData>. */
+type ConsentFn = Fn$2<Consent>;
+type GenericFn = Fn$2<unknown>;
+type ReadyFn = Fn$2<void>;
+type RunFn = Fn$2<void>;
+type SessionFn = Fn$2<SessionData | undefined>;
+type UserFn = Fn$2<User>;
+/**
+ * Consent rule: a record of `{ [consentKey]: ConsentFn }`.
+ * Only the consent action uses this shape (per-key handler dispatch).
+ */
+interface ConsentRule {
     [key: string]: ConsentFn;
 }
-type ConsentFn = (collector: Instance$6, consent: Consent) => void;
-type GenericConfig = GenericFn;
-type GenericFn = (collector: Instance$6, data: unknown) => void;
-type ReadyConfig = ReadyFn;
-type ReadyFn = (collector: Instance$6) => void;
-type RunConfig = RunFn;
-type RunFn = (collector: Instance$6) => void;
-type SessionConfig = SessionFn;
-type SessionFn = (collector: Instance$6, session?: unknown) => void;
-type UserConfig = UserFn;
-type UserFn = (collector: Instance$6, user: User) => void;
+/** Anything registerable via `walker.on(action, X)`: a typed callback or a consent rule record. */
+type Subscription = ConsentRule | GenericFn | ReadyFn | RunFn | SessionFn | UserFn;
 interface OnConfig {
-    config?: GenericConfig[];
-    consent?: ConsentConfig[];
-    custom?: GenericConfig[];
-    globals?: GenericConfig[];
-    ready?: ReadyConfig[];
-    run?: RunConfig[];
-    session?: SessionConfig[];
-    user?: UserConfig[];
-    [key: string]: ConsentConfig[] | GenericConfig[] | ReadyConfig[] | RunConfig[] | SessionConfig[] | UserConfig[] | undefined;
+    config?: GenericFn[];
+    consent?: ConsentRule[];
+    custom?: GenericFn[];
+    globals?: GenericFn[];
+    ready?: ReadyFn[];
+    run?: RunFn[];
+    session?: SessionFn[];
+    user?: UserFn[];
+    [key: string]: ConsentRule[] | GenericFn[] | ReadyFn[] | RunFn[] | SessionFn[] | UserFn[] | undefined;
 }
+/**
+ * Destination `on` handler: receives the action type and a destination context.
+ * Already context-style; kept for compatibility with the destination interface.
+ */
 type OnFn<T extends TypesGeneric$3 = Types$4> = (type: Types$3, context: Context$5<T>) => PromiseOrValue<void>;
 type OnFnRuntime = (type: Types$3, context: Context$5) => PromiseOrValue<void>;
 
-type on_AnyEventContext = AnyEventContext;
-type on_ConsentConfig = ConsentConfig;
+type on_AnyEventData = AnyEventData;
 type on_ConsentFn = ConsentFn;
-type on_EventContext<T extends keyof EventContextMap> = EventContext<T>;
-type on_EventContextMap = EventContextMap;
-type on_GenericConfig = GenericConfig;
+type on_ConsentRule = ConsentRule;
+type on_EventData<T extends keyof EventDataMap> = EventData<T>;
+type on_EventDataMap = EventDataMap;
 type on_GenericFn = GenericFn;
 type on_OnConfig = OnConfig;
 type on_OnFn<T extends TypesGeneric$3 = Types$4> = OnFn<T>;
 type on_OnFnRuntime = OnFnRuntime;
-type on_Options = Options;
-type on_ReadyConfig = ReadyConfig;
 type on_ReadyFn = ReadyFn;
-type on_RunConfig = RunConfig;
 type on_RunFn = RunFn;
-type on_SessionConfig = SessionConfig;
 type on_SessionFn = SessionFn;
-type on_UserConfig = UserConfig;
+type on_Subscription = Subscription;
 type on_UserFn = UserFn;
 declare namespace on {
-  export type { on_AnyEventContext as AnyEventContext, Config$3 as Config, on_ConsentConfig as ConsentConfig, on_ConsentFn as ConsentFn, Context$4 as Context, on_EventContext as EventContext, on_EventContextMap as EventContextMap, on_GenericConfig as GenericConfig, on_GenericFn as GenericFn, on_OnConfig as OnConfig, on_OnFn as OnFn, on_OnFnRuntime as OnFnRuntime, on_Options as Options, on_ReadyConfig as ReadyConfig, on_ReadyFn as ReadyFn, on_RunConfig as RunConfig, on_RunFn as RunFn, on_SessionConfig as SessionConfig, on_SessionFn as SessionFn, Types$3 as Types, on_UserConfig as UserConfig, on_UserFn as UserFn };
+  export type { on_AnyEventData as AnyEventData, Config$3 as Config, on_ConsentFn as ConsentFn, on_ConsentRule as ConsentRule, Context$4 as Context, on_EventData as EventData, on_EventDataMap as EventDataMap, Fn$2 as Fn, on_GenericFn as GenericFn, on_OnConfig as OnConfig, on_OnFn as OnFn, on_OnFnRuntime as OnFnRuntime, on_ReadyFn as ReadyFn, on_RunFn as RunFn, on_SessionFn as SessionFn, on_Subscription as Subscription, Types$3 as Types, on_UserFn as UserFn };
 }
 
 interface NextRule {
@@ -1575,7 +1590,7 @@ interface BaseEnv$1 {
     push: PushFn$1;
     command: CommandFn;
     sources?: Sources;
-    elb: Fn$2;
+    elb: Fn$3;
     logger: Instance$4;
 }
 /**
@@ -1588,7 +1603,7 @@ interface BaseEnv$1 {
  * @template E - Environment dependencies type
  * @template I - InitSettings configuration type (user input)
  */
-interface Types$1<S = unknown, M = unknown, P = Fn$2, E = BaseEnv$1, I = S> {
+interface Types$1<S = unknown, M = unknown, P = Fn$3, E = BaseEnv$1, I = S> {
     settings: S;
     initSettings: I;
     mapping: M;
@@ -1794,7 +1809,7 @@ interface FlowHandle {
     /** The collector instance created by startFlow. */
     collector: Instance$6;
     /** The elb push function for direct event injection. */
-    elb: Fn$2;
+    elb: Fn$3;
 }
 /** What createTrigger returns — a flow handle (lazy) and a trigger function. */
 interface Instance<TContent = unknown, TResult = unknown> {
@@ -1862,7 +1877,7 @@ declare namespace trigger {
 }
 
 type AnyObject<T = unknown> = Record<string, T>;
-type Elb = Fn$2;
+type Elb = Fn$3;
 type AnyFunction = (...args: unknown[]) => unknown;
 type SingleOrArray<T> = T | Array<T>;
 type Events = Array<Event>;
@@ -2492,9 +2507,10 @@ declare function createLogger(config?: Config$4): Instance$4;
  *
  * @param event The event to get the mapping for (can be partial or full).
  * @param mapping The mapping rules.
+ * @param collector Required to evaluate rule-level conditions against the unified Context. Legacy callers may omit; rule-level conditions then run with `undefined as never` (defensive).
  * @returns The mapping result.
  */
-declare function getMappingEvent(event: DeepPartialEvent | PartialEvent | Event, mapping?: Rules): Promise<Result$2>;
+declare function getMappingEvent(event: DeepPartialEvent | PartialEvent | Event, mapping?: Rules, collector?: Instance$6): Promise<Result$2>;
 /**
  * Gets a value from a mapping.
  *
@@ -2503,7 +2519,7 @@ declare function getMappingEvent(event: DeepPartialEvent | PartialEvent | Event,
  * @param options The mapping options.
  * @returns The mapped value.
  */
-declare function getMappingValue(value: DeepPartialEvent | unknown | undefined, data?: Data$1, options?: Options$1): Promise<Property | undefined>;
+declare function getMappingValue(value: DeepPartialEvent | unknown | undefined, data?: Data$1, context?: Partial<Context$6>): Promise<Property | undefined>;
 /**
  * Processes an event through mapping configuration.
  *
@@ -2821,82 +2837,52 @@ declare function getDeviceType(userAgent: string): string | undefined;
 /**
  * Inline Code Wrapping Utilities
  *
- * Converts inline code strings to executable functions.
- * Used for mapping properties: condition, fn, validate.
+ * Converts inline code strings to executable functions for the three mapping
+ * callbacks: condition, fn, validate. All three share a single signature:
+ *
+ *   (value, context) => result
+ *
+ * Inside the inline body, the available bindings are:
+ *   - value:    unknown - the value being mapped/validated/checked
+ *   - context:  Mapping.Context with these fields:
+ *       event:     WalkerOS.DeepPartialEvent
+ *       mapping:   Mapping.Value | Mapping.Rule
+ *       collector: Collector.Instance
+ *       logger:    Logger.Instance
+ *       consent?:  WalkerOS.Consent
+ *
+ * If the body has no explicit `return`, it is auto-wrapped with `return`.
  *
  * @packageDocumentation
  */
 
 /**
- * Wrap inline code string as Condition function.
- *
- * @param code - Inline code string
- * @returns Condition function matching Mapping.Condition signature
- *
- * @remarks
- * Available parameters in code:
- * - `value` - The event or partial event being processed
- * - `mapping` - Current mapping configuration
- * - `collector` - Collector instance
- *
- * If code has no explicit return, it's auto-wrapped with `return`.
+ * Wrap inline code as a Mapping.Condition.
  *
  * @example
- * ```typescript
- * // One-liner (auto-wrapped)
- * const fn = wrapCondition('value.data.total > 100');
- * fn(event, mapping, collector); // returns boolean
- *
- * // Multi-statement (explicit return)
- * const fn = wrapCondition('const threshold = 100; return value.data.total > threshold');
+ * ```ts
+ * const c = wrapCondition('context.consent?.marketing === true');
+ * c(value, context); // boolean
  * ```
  */
 declare function wrapCondition(code: string): Condition;
 /**
- * Wrap inline code string as Fn function.
- *
- * @param code - Inline code string
- * @returns Fn function matching Mapping.Fn signature
- *
- * @remarks
- * Available parameters in code:
- * - `value` - The event or partial event being processed
- * - `mapping` - Current mapping configuration
- * - `options` - Options object with consent and collector
- *
- * If code has no explicit return, it's auto-wrapped with `return`.
+ * Wrap inline code as a Mapping.Fn.
  *
  * @example
- * ```typescript
- * // One-liner (auto-wrapped)
+ * ```ts
  * const fn = wrapFn('value.user.email.split("@")[1]');
- * fn(event, mapping, options); // returns domain
- *
- * // Multi-statement (explicit return)
- * const fn = wrapFn('const parts = value.user.email.split("@"); return parts[1].toUpperCase()');
+ * fn(value, context); // domain
  * ```
  */
-declare function wrapFn(code: string): Fn$3;
+declare function wrapFn(code: string): Fn$4;
 /**
- * Wrap inline code string as Validate function.
- *
- * @param code - Inline code string
- * @returns Validate function matching Mapping.Validate signature
- *
- * @remarks
- * Available parameters in code:
- * - `value` - The current value being validated
- *
- * If code has no explicit return, it's auto-wrapped with `return`.
+ * Wrap inline code as a Mapping.Validate.
  *
  * @example
- * ```typescript
- * // One-liner (auto-wrapped)
- * const fn = wrapValidate('value && value.length > 0');
- * fn('hello'); // returns true
- *
- * // Multi-statement (explicit return)
- * const fn = wrapValidate('if (!value) return false; return value.length > 0');
+ * ```ts
+ * const v = wrapValidate('typeof value === "string" && value.length > 0');
+ * v(value, context); // boolean
  * ```
  */
 declare function wrapValidate(code: string): Validate;
@@ -3030,7 +3016,7 @@ declare function buildCacheContext(ingest?: unknown, event?: unknown): Record<st
 declare function compileCache(cache: Cache): CompiledCache;
 declare function checkCache(compiled: CompiledCache, store: Instance$1, context: Record<string, unknown>, namespace: string): CacheResult | null;
 declare function storeCache(store: Instance$1, key: string, value: unknown, ttlSeconds: number): void;
-declare function applyUpdate(value: unknown, update: Record<string, unknown> | undefined, context: Record<string, unknown>): Promise<unknown>;
+declare function applyUpdate(value: unknown, update: Record<string, unknown> | undefined, context: Record<string, unknown>, collector: Instance$6): Promise<unknown>;
 
 type StepOut = Flow.StepOut;
 /**
@@ -3064,8 +3050,10 @@ declare const REF_VAR: RegExp;
 declare const REF_DEF: RegExp;
 declare const REF_ENV: RegExp;
 declare const REF_CONTRACT: RegExp;
+/** Whole-string `$flow.<name>(.<path>)?`: cross-flow value reference. */
+declare const REF_FLOW: RegExp;
 declare const REF_STORE: RegExp;
 declare const REF_SECRET: RegExp;
 declare const REF_CODE_PREFIX = "$code:";
 
-export { cache as Cache, type CacheResult, type ClickIdEntry, collector as Collector, type CompiledCache, type CompiledNext, type CompiledRoute, Const, context as Context, destination as Destination, ENV_MARKER_PREFIX, elb as Elb, type ExampleSummary, Flow, type FlowConfigResolver, hint as Hint, hooks as Hooks, type Ingest, type IngestMeta, Level, lifecycle as Lifecycle, logger as Logger, mapping as Mapping, type MarketingParameters, matcher as Matcher, type MockLogger, on as On, REF_CODE_PREFIX, REF_CONTRACT, REF_DEF, REF_ENV, REF_SECRET, REF_STORE, REF_VAR, request as Request, type ResolveOptions, type RespondFn, type RespondOptions, type SendDataValue, type SendHeaders, type SendResponse, simulation as Simulation, source as Source, type StorageType, store as Store, transformer as Transformer, trigger as Trigger, walkeros as WalkerOS, type WalkerOSPackage, type WalkerOSPackageInfo, type WalkerOSPackageMeta, anonymizeIP, applyUpdate, assign, branch, buildCacheContext, castToProperty, castValue, checkCache, clone, compileCache, compileMatcher, compileNext, createDestination, createEvent, createIngest, createLogger, createMockContext, createMockLogger, createRespond, debounce, deepMerge, defaultClickIds, fetchPackage, fetchPackageSchema, filterValues, flattenIncludeSections, formatOut, getBrowser, getBrowserVersion, getByPath, getDeviceType, getEvent, getFlowSettings, getGrantedConsent, getHeaders, getId, getMappingEvent, getMappingValue, getMarketingParameters, getOS, getOSVersion, getPlatform, getSpanId, isArguments, isArray, isBoolean, isCommand, isDefined, isElementOrDocument, isFunction, isNumber, isObject, isPropertyType, isRouteArray, isSameType, isString, mcpError, mcpResult, mergeContractSchemas, mockEnv, packageNameToVariable, parseUserAgent, processEventMapping, requestToData, requestToParameter, resolveContracts, resolveNext, setByPath, storeCache, throttle, throwError, transformData, traverseEnv, trim, tryCatch, tryCatchAsync, useHooks, walkPath, wrapCondition, wrapFn, wrapValidate };
+export { cache as Cache, type CacheResult, type ClickIdEntry, collector as Collector, type CompiledCache, type CompiledNext, type CompiledRoute, Const, context as Context, destination as Destination, ENV_MARKER_PREFIX, elb as Elb, type ExampleSummary, Flow, type FlowConfigResolver, hint as Hint, hooks as Hooks, type Ingest, type IngestMeta, Level, lifecycle as Lifecycle, logger as Logger, mapping as Mapping, type MarketingParameters, matcher as Matcher, type MockLogger, on as On, REF_CODE_PREFIX, REF_CONTRACT, REF_DEF, REF_ENV, REF_FLOW, REF_SECRET, REF_STORE, REF_VAR, request as Request, type ResolveOptions, type RespondFn, type RespondOptions, type SendDataValue, type SendHeaders, type SendResponse, simulation as Simulation, source as Source, type StorageType, store as Store, transformer as Transformer, trigger as Trigger, walkeros as WalkerOS, type WalkerOSPackage, type WalkerOSPackageInfo, type WalkerOSPackageMeta, anonymizeIP, applyUpdate, assign, branch, buildCacheContext, castToProperty, castValue, checkCache, clone, compileCache, compileMatcher, compileNext, createDestination, createEvent, createIngest, createLogger, createMockContext, createMockLogger, createRespond, debounce, deepMerge, defaultClickIds, fetchPackage, fetchPackageSchema, filterValues, flattenIncludeSections, formatOut, getBrowser, getBrowserVersion, getByPath, getDeviceType, getEvent, getFlowSettings, getGrantedConsent, getHeaders, getId, getMappingEvent, getMappingValue, getMarketingParameters, getOS, getOSVersion, getPlatform, getSpanId, isArguments, isArray, isBoolean, isCommand, isDefined, isElementOrDocument, isFunction, isNumber, isObject, isPropertyType, isRouteArray, isSameType, isString, mcpError, mcpResult, mergeContractSchemas, mockEnv, packageNameToVariable, parseUserAgent, processEventMapping, requestToData, requestToParameter, resolveContracts, resolveNext, setByPath, storeCache, throttle, throwError, transformData, traverseEnv, trim, tryCatch, tryCatchAsync, useHooks, walkPath, wrapCondition, wrapFn, wrapValidate };