@walkeros/core 4.4.0-next-1785285516008 → 4.5.0

package/dist/index.d.mts

@@ -553,6 +553,14 @@ interface SourceStatus {
     count: number;
     lastAt?: number;
     duration: number;
+    /**
+     * Monotonic count of inbound input rejected before entering the pipeline:
+     * the source bumps it for HTTP-boundary rejections (unparseable body,
+     * oversized payload, unsupported charset), the collector bumps it for
+     * events rejected as invalid at the pipeline gate. Absent means no
+     * rejections were tracked.
+     */
+    rejected?: number;
 }
 interface DestinationStatus {
     count: number;
@@ -672,6 +680,15 @@ interface Instance$6 {
     logger: Instance$3;
     on: OnConfig;
     queue: Events;
+    /**
+     * Events pushed while `allowed === false`, held raw (pre-pipeline) and
+     * replayed FIFO by the run command. Bounded by `config.queueMax`
+     * (drop-oldest). RECORD-immediate/DELIVER-gated, extended to events.
+     */
+    preRunQueue: Array<{
+        event: DeepPartialEvent;
+        options: PushOptions;
+    }>;
     round: number;
     /** Run-scoped W3C trace id, minted on each run and stamped onto events. */
     trace?: string;
@@ -1311,6 +1328,10 @@ interface PushResult {
     failed?: Record<string, Ref>;
     /** Event was intentionally not forwarded: a transformer chain stopped it. */
     dropped?: boolean;
+    /** Event was rejected as invalid input: a client/producer fault, not a pipeline failure. */
+    invalid?: boolean;
+    /** Human-readable failure reason when ok is false. */
+    error?: string;
 }
 type Layer = Array<IArguments | DeepPartialEvent | unknown[]>;
 
@@ -2560,8 +2581,12 @@ declare namespace request {
 /**
  * Base Env interface for dependency injection into sources.
  *
- * Sources receive all their dependencies through this environment object,
- * making them platform-agnostic and easily testable.
+ * `env` is the author's dependency bag: platform and vendor dependencies are
+ * injected here, making sources platform-agnostic. The five capabilities the
+ * collector provides (`push`, `command`, `sources`, `elb`, `logger`) are
+ * runtime-owned and applied last, so author values for them are ignored. To
+ * mock the collector boundary in a test, call the factory directly with a
+ * hand-built `Context`, or declare `InitSource.terminus`.
  */
 interface BaseEnv$1 {
     [key: string]: unknown;
@@ -2636,17 +2661,18 @@ interface Config$1<T extends TypesGeneric$1 = Types$1> extends Config$7<Mapping<
     /**
      * Respond-first acknowledgement for response-producing server sources.
      *
-     * When a source produces an HTTP response (express today; future fetch /
-     * lambda), `async: true` (the default for such sources) responds 2xx
-     * ("accepted") before the event is delivered to the collector, so the
-     * client is not blocked on backend delivery. `async: false` waits for
-     * delivery to settle before responding. A 2xx means "accepted", not
-     * "delivered".
+     * `true` responds 2xx ("accepted") before the event is delivered to the
+     * collector, so the client is not blocked on backend delivery; `false`
+     * waits for delivery to settle before responding and lets the response
+     * reflect the outcome. A record configures this per source-defined key:
+     * the express source keys it by HTTP method (`GET`/`POST`) and defaults
+     * to `{ GET: false, POST: true }`, so a step can serve real content on
+     * GET while POST acks fast. A 2xx means "accepted", not "delivered".
      *
      * Browser and dataLayer sources have no HTTP response to defer and ignore
-     * this flag. The default is per source type.
+     * this flag. Defaults are per source type.
      */
-    async?: boolean;
+    async?: boolean | Record<string, boolean>;
     /** Mark as primary source; its push function becomes the exported `elb` from startFlow. */
     primary?: boolean;
     /** Defer source initialization until these collector events fire (e.g., `['consent']`). */
@@ -2658,14 +2684,15 @@ interface Config$1<T extends TypesGeneric$1 = Types$1> extends Config$7<Mapping<
     setup?: boolean | SetupOptions$1<T>;
     /**
      * Ingest metadata extraction mapping.
-     * Extracts values from raw request objects (Express req, Lambda event, etc.)
-     * using walkerOS mapping syntax. Extracted data flows to transformers/destinations.
+     * Extracts values from the normalized `Scope` the source built, using
+     * walkerOS mapping syntax. Extracted data flows to transformers and
+     * destinations. Paths resolve against the scope's fields, with no prefix.
      *
      * @example
      * ingest: {
-     *   ip: 'req.ip',
-     *   ua: 'req.headers.user-agent',
-     *   origin: 'req.headers.origin'
+     *   ip: 'ip',
+     *   ua: 'headers.user-agent',
+     *   origin: 'headers.origin'
      * }
      */
     ingest?: Data$1;
@@ -2725,6 +2752,36 @@ type ScopeEnv<T extends TypesGeneric$1 = Types$1> = Env$1<T> & {
     /** Respond function bound to this scope (undefined for scopes without a response). */
     respond?: RespondFn;
 };
+/**
+ * The normalized shape every source builds from its platform's request before
+ * calling withScope. Downstream config.ingest mappings, transformers and
+ * destinations read this shape and nothing else, so a mapping written once
+ * resolves the same on every source.
+ *
+ * A value a platform does not supply is never guessed. `ip` is the one optional
+ * field and is simply absent there; the required fields carry a documented
+ * empty value instead (`url` is `''` when the platform cannot form one). `raw`
+ * carries the untouched platform object for the cases normalization
+ * deliberately does not cover.
+ */
+interface Scope {
+    /** Uppercase HTTP method. */
+    method: string;
+    /** Absolute request URL when the platform knows it, else ''. */
+    url: string;
+    /** Pathname only, no query string, leading slash. */
+    path: string;
+    /** Query parameters. Repeated keys joined with ','. */
+    query: Record<string, string>;
+    /** Header bag. Keys lowercased. Repeated values joined with ', '. */
+    headers: Record<string, string>;
+    /** Parsed body when it parses as JSON, the raw string when it does not, undefined when there is none. */
+    body: unknown;
+    /** Client IP as the platform reports it. Absent when the platform does not report one. */
+    ip?: string;
+    /** The untouched platform object. Escape hatch, never read by walkerOS itself. */
+    raw: unknown;
+}
 /**
  * Context provided to source init function.
  * Extends base context with source-specific properties.
@@ -2734,29 +2791,32 @@ interface Context$1<T extends TypesGeneric$1 = Types$1> extends Base<Partial<Con
     /**
      * Bind ingest and respond to a single scope of work (e.g. one inbound
      * HTTP request, one queue message). Builds a fresh `Ingest` from the
-     * raw input via `config.ingest` mapping, wires the per-scope `respond`,
-     * and invokes `body(scopeEnv)` with a push function that captures both.
+     * normalized scope via `config.ingest` mapping, wires the per-scope
+     * `respond`, and invokes `body(scopeEnv)` with a push function that
+     * captures both.
      *
-     * Server sources call this once per inbound request:
+     * Server sources normalize their platform's request into a `Scope` first,
+     * then call this once per inbound request:
      *
      * ```ts
-     * await context.withScope(req, createRespond(sender), async (env) => {
-     *   await env.push(parsedData);
+     * const scope = buildScope(req);
+     *
+     * await context.withScope(scope, createRespond(sender), async (env) => {
+     *   for (const event of toEventList(scope.body)) await env.push(event);
      * });
      * ```
      *
      * Browser sources with a single tab-lifetime scope may skip `withScope`
      * and use `env.push` directly.
      *
-     * @param rawScope - Raw input for `config.ingest` mapping (Express req,
-     *   Lambda event, fetch Request, etc.). Pass `undefined` if no ingest
-     *   mapping applies.
+     * @param rawScope - The normalized scope the source built from its
+     *   platform's request. Pass `undefined` if no ingest mapping applies.
      * @param respond - Per-scope respond function, or `undefined` if the
      *   scope produces no response.
      * @param body - Async callback receiving the per-scope env.
      * @returns The body's return value.
      */
-    withScope: <R>(rawScope: unknown, respond: RespondFn | undefined, body: (env: ScopeEnv<T>) => Promise<R>) => Promise<R>;
+    withScope: <R>(rawScope: Scope | undefined, respond: RespondFn | undefined, body: (env: ScopeEnv<T>) => Promise<R>) => Promise<R>;
 }
 type Init$1<T extends TypesGeneric$1 = Types$1> = (context: Context$1<T>) => Instance$2<T> | Promise<Instance$2<T>>;
 type InitSource<T extends TypesGeneric$1 = Types$1> = {
@@ -2766,6 +2826,21 @@ type InitSource<T extends TypesGeneric$1 = Types$1> = {
     primary?: boolean;
     next?: Route;
     before?: Route;
+    /**
+     * Replace the collector at the END of this source's pipeline.
+     *
+     * A terminus receives the event exactly as the source emitted it and the
+     * entire pipeline is skipped: no `before`/`next` chains, no source `cache`,
+     * no `state`, no `mapping`, no minted span id, no per-source ingest, no
+     * `respond`, no `status.sources` counting and no observability records.
+     *
+     * This is a TOTAL bypass, deliberately, so there is one thing to know rather
+     * than a list of exceptions. It exists for deterministic capture at the
+     * source→collector boundary (step examples, dev tooling). Production flows
+     * leave it unset. Runtime-only: stored-flow validation rejects unknown
+     * source keys, so a persisted flow cannot carry it.
+     */
+    terminus?: PushFn$1;
     cache?: Cache;
     state?: State | State[];
 };
@@ -2808,10 +2883,11 @@ type source_InitSources = InitSources;
 type source_Mapping<T extends TypesGeneric$1 = Types$1> = Mapping<T>;
 type source_Push<T extends TypesGeneric$1 = Types$1> = Push<T>;
 type source_Renderer = Renderer;
+type source_Scope = Scope;
 type source_ScopeEnv<T extends TypesGeneric$1 = Types$1> = ScopeEnv<T>;
 declare const source_getSource: typeof getSource;
 declare namespace source {
-  export { type BaseEnv$1 as BaseEnv, type Config$1 as Config, type Context$1 as Context, type Credentials$1 as Credentials, type Env$1 as Env, type Init$1 as Init, type InitSettings$1 as InitSettings, type source_InitSource as InitSource, type source_InitSources as InitSources, type Instance$2 as Instance, type source_Mapping as Mapping, type PartialConfig$1 as PartialConfig, type source_Push as Push, type source_Renderer as Renderer, type source_ScopeEnv as ScopeEnv, type Settings$1 as Settings, type SetupOptions$1 as SetupOptions, type Types$1 as Types, type TypesGeneric$1 as TypesGeneric, type TypesOf$1 as TypesOf, source_getSource as getSource };
+  export { type BaseEnv$1 as BaseEnv, type Config$1 as Config, type Context$1 as Context, type Credentials$1 as Credentials, type Env$1 as Env, type Init$1 as Init, type InitSettings$1 as InitSettings, type source_InitSource as InitSource, type source_InitSources as InitSources, type Instance$2 as Instance, type source_Mapping as Mapping, type PartialConfig$1 as PartialConfig, type source_Push as Push, type source_Renderer as Renderer, type source_Scope as Scope, type source_ScopeEnv as ScopeEnv, type Settings$1 as Settings, type SetupOptions$1 as SetupOptions, type Types$1 as Types, type TypesGeneric$1 as TypesGeneric, type TypesOf$1 as TypesOf, source_getSource as getSource };
 }
 
 interface BaseEnv {
@@ -4356,6 +4432,17 @@ declare class FatalError extends Error {
     constructor(message: string, options?: ErrorOptions);
 }
 
+/**
+ * Inbound event rejected as invalid input (e.g. missing or malformed name)
+ * after the pre-collector transformer chain had its chance to enrich it.
+ * A client/producer fault, not a pipeline failure: the collector resolves
+ * it as `{ ok: false, invalid: true }` instead of an error-logged crash,
+ * and HTTP sources map it to a 400-class response.
+ */
+declare class InvalidEventError extends Error {
+    constructor(message: string);
+}
+
 /**
  * A utility function that wraps a function with hooks.
  *
@@ -4929,10 +5016,12 @@ declare function fetchPackageSchema(packageName: string, options?: {
 /** Options for {@link resolveContracts}. */
 interface ResolveContractsOptions {
     /**
-     * When true (default), annotation keys (`description`, `examples`, `title`,
-     * `$comment`) are stripped from event schemas so the result is AJV-clean for
-     * runtime validation. Set to false to keep annotations (e.g. for IntelliSense
-     * that surfaces property descriptions).
+     * When true (default), annotation keywords (`description`, `examples`,
+     * `title`, `$comment`) are stripped from event schemas. Validators ignore
+     * annotations, so this never changes a validation verdict; it only trims
+     * resolved artifacts, e.g. contracts inlined into shipped bundles. Set to
+     * false to keep annotations (e.g. for IntelliSense that surfaces property
+     * descriptions).
      */
     stripAnnotations?: boolean;
 }
@@ -4943,9 +5032,8 @@ interface ResolveContractsOptions {
  * Returns a fully resolved map where each contract entry has inherited
  * properties merged in and wildcards expanded into concrete actions.
  *
- * By default annotations are stripped (AJV-clean). Pass
- * `{ stripAnnotations: false }` to preserve `description`/`examples`/`title`
- * on event schemas.
+ * By default annotations are stripped. Pass `{ stripAnnotations: false }` to
+ * preserve `description`/`examples`/`title` on event schemas.
  */
 declare function resolveContracts(contracts: Flow.Contract, options?: ResolveContractsOptions): Record<string, Flow.ContractRule>;
 /**
@@ -4995,6 +5083,175 @@ declare function mcpError(error: unknown, hint?: string): {
     isError: true;
 };
 
+/**
+ * Normalizes a platform header collection into a plain bag with lowercased
+ * keys and string values.
+ *
+ * Accepts a Fetch `Headers` instance, a Node style header bag whose values may
+ * be arrays, or anything else, which yields an empty bag. Repeated values are
+ * joined with ', ' following the RFC 9110 rule for combining field values, so
+ * a consumer never has to branch on the value type.
+ *
+ * @param input The platform header collection.
+ * @returns Header names lowercased, values as strings.
+ */
+declare function normalizeHeaders(input: unknown): Record<string, string>;
+/**
+ * Normalizes a query string into a flat bag of string values.
+ *
+ * One algorithm on every platform, so a mapping resolves the same everywhere.
+ * Repeated keys are joined with ',' rather than kept as arrays, matching the
+ * single string value type the scope contract promises. Structured parsing
+ * stays available through the scope's `raw`.
+ *
+ * @param queryString The query string, with or without a leading '?'.
+ * @returns Query parameters as strings.
+ */
+declare function normalizeQuery(queryString: string): Record<string, string>;
+/**
+ * Normalizes a request body into the value it represents.
+ *
+ * Parsing happens once, at the source boundary, so `ingest.body` and the event
+ * the pipeline receives can never disagree. A body that does not parse as JSON
+ * is returned unchanged, which is what lets a `source.before` transformer
+ * decode raw input.
+ *
+ * @param body The raw body.
+ * @param base64 Whether the body is base64 encoded and must be decoded first.
+ * @returns The parsed value, or the input unchanged when it does not parse.
+ */
+declare function normalizeBody(body: unknown, base64?: boolean): unknown;
+/**
+ * Reports whether a value satisfies the scope contract's shape.
+ *
+ * Sources can be user authored, so a consumer that must not assume the type
+ * holds at runtime uses this rather than trusting the declaration.
+ *
+ * @param value The value to check.
+ * @returns True when the value carries the required scope fields.
+ */
+declare function isScope(value: unknown): value is Scope;
+/**
+ * The fields a Node style request exposes that scope construction reads.
+ *
+ * Structural, so core stays free of any framework dependency. Express and the
+ * GCP Functions Framework both satisfy it; the Functions Framework hands the
+ * handler an Express request.
+ */
+interface NodeLikeRequest {
+    method?: string;
+    headers?: unknown;
+    originalUrl?: string;
+    url?: string;
+    path?: string;
+    protocol?: string;
+    ip?: string;
+    get?: (name: string) => string | undefined;
+}
+/**
+ * Builds the normalized scope from a Node style request.
+ *
+ * Every read tolerates a partial request: sub-app mounting changes which of
+ * `originalUrl` and `url` carries the full path, and a scope that throws on a
+ * missing optional would turn scope construction into a 500 for the whole
+ * request. A missing field yields the contract's empty value.
+ *
+ * The body is supplied by the caller rather than read here, because each
+ * platform decides whether it arrives already parsed.
+ *
+ * @param req The request.
+ * @param options `body` is the resolved request body. `defaultProtocol` is used
+ *   when the request and its headers name none.
+ * @returns The normalized scope.
+ */
+declare function buildScopeFromNodeRequest(req: NodeLikeRequest, options: {
+    body: unknown;
+    defaultProtocol: string;
+}): Scope;
+
+/**
+ * Normalize an inbound request body into the list of events it carries.
+ *
+ * Four rules, in order:
+ * 1. A bare top-level array is N events.
+ * 2. An object with an array `batch` key is N events, the canonical envelope.
+ * 3. Any other object is one event, forwarded verbatim.
+ * 4. Anything else (a string, a number, null, an unparseable body) is raw
+ *    input, yielding a single empty event so a `source.before` chain can
+ *    decode it from `ingest.body`.
+ *
+ * Validation is not performed here: an object that is not a valid event
+ * reaches the collector's gate, which is the one place that decides what an
+ * event is. An explicit empty batch is a well-formed request carrying zero
+ * events, so it yields an empty list rather than a raw-input event.
+ *
+ * @param body The parsed request body.
+ * @returns The events the body carries.
+ */
+declare function toEventList(body: unknown): DeepPartialEvent[];
+/**
+ * Reports whether a body used a batch form, independently of how many events
+ * it carries.
+ *
+ * Form and count are two different questions. A one element batch is still a
+ * batch, and answers with the batch response shape, so a caller must not infer
+ * the form from the event count.
+ *
+ * @param body The parsed request body.
+ * @returns True for a bare array or an object with an array `batch` key.
+ */
+declare function isBatchBody(body: unknown): boolean;
+/**
+ * The outcome of delivering one event of a batch.
+ *
+ * `id` is present when the event was accepted and minted one. `error` is
+ * present when it was not accepted.
+ */
+interface EventOutcome {
+    id?: string;
+    error?: string;
+}
+/** A batch response: the status to answer with, and the body to send. */
+interface BatchResponse {
+    status: 200 | 207;
+    body: {
+        success: boolean;
+        processed: number;
+        failed?: number;
+        ids?: (string | null)[];
+        errors?: Array<{
+            index: number;
+            error: string;
+        }>;
+    };
+}
+/**
+ * Builds the shared batch response from per event outcomes.
+ *
+ * One assembly for every source, so the status, the field names and the index
+ * alignment cannot drift apart. `ids` is index aligned with the submitted
+ * batch: an accepted event with no id is `null` rather than omitted, so
+ * `ids[i]` always describes the caller's `i`th event.
+ *
+ * @param outcomes One entry per event, in submission order.
+ * @returns The status and body to answer with.
+ */
+declare function batchResponse(outcomes: EventOutcome[]): BatchResponse;
+/**
+ * Maps a collector push result onto a batch event outcome.
+ *
+ * @param result The push result, or undefined when the push returned none.
+ * @returns The outcome for this event.
+ */
+declare function pushResultToOutcome(result: {
+    ok?: boolean;
+    invalid?: boolean;
+    error?: string;
+    event?: {
+        id?: string;
+    };
+}): EventOutcome;
+
 /**
  * Compiles a match expression into a closure for fast runtime evaluation.
  * Regex patterns are compiled once. Numeric comparisons are parsed once.
@@ -5227,4 +5484,4 @@ declare const REF_CODE_PREFIX = "$code:";
  */
 declare function scanFlowRefs(value: unknown, into?: Set<string>): Set<string>;
 
-export { type ActivationGrant, type AssembleJourneysOptions, type BatchedPosterOptions, type BreakerState, CLOCK_SKEW_MS, cache as Cache, type CacheEnvelope, type CacheResult, type ClickIdEntry, collector as Collector, type CompiledCache, Const, context as Context, type Credential, type Debounced, destination as Destination, type DestroyContext, type DestroyFn, type DroppedCounters, ENV_MARKER_PREFIX, elb as Elb, type EmitFn, type ExampleSummary, FatalError, Flow, type FlowConfigResolver, type FlowState, type FlowStateBatch, type FlowStatePhase, type FlowStepType, type GetStore, hint as Hint, hooks as Hooks, type Ingest, type IngestEnvelope, type IngestMeta, type Journey, type JourneyAssembly, type JourneyBranch, type JourneyCorrelation, type JourneyEntry, type JourneyGap, type JourneyHop, type JourneyHopStatus, type JourneyPlatform, type JourneyStatus, type JourneyTopology, type JourneyTopologyNode, type JourneyUnattributed, type JsonSchema, Level, lifecycle as Lifecycle, type LifecycleContext, logger as Logger, MAX_SESSION_MS, mapping as Mapping, type MarketingParameters, matcher as Matcher, type MockLogger, OBSERVE_ENV_KEY, OBSERVE_STORAGE_KEY, type Observe, type ObserveCredential, type ObserveServer, type ObserveWeb, type ObserverFn, on as On, type ParsedGrant, type ParsedTraceparent, type PosterFetch, type PosterResponse, type PreviewCrypto, type PreviewFailure, type PreviewKey, type PreviewSubtle, REF_CODE_PREFIX, REF_CONTRACT, REF_ENV, REF_FLOW, REF_SECRET, REF_STORE, REF_VAR_FULL, REF_VAR_INLINE, request as Request, type ResolveContractsOptions, type ResolveOptions, type RespondFn, type RespondOptions, SECRET_MARKER_PREFIX, SESSION_STORAGE_KEY, STEP_OPERATIVE_FIELDS, type ScheduleOptions, type SendDataValue, type SendHeaders, type SendResponse, type ServiceAccount, type SetupFn, simulation as Simulation, source as Source, type State, type StepEntryErrorCode, type StepEntryValidation, type StepKind, type StorageType, store as Store, StoreCodecError, type SwapActivatorConfig, type TelemetryLevel, type TelemetryOptions, type TelemetryOptionsSupplier, transformer as Transformer, trigger as Trigger, URL_WINDOW_MS, type ValidateEvents, type VerifyParams, type VerifyResult, walkeros as WalkerOS, type WalkerOSPackage, type WalkerOSPackageInfo, type WalkerOSPackageMeta, anonymizeIP, applyState, applyUpdate, assembleJourneys, assign, branch, browserSwapActivator, buildCacheContext, castToProperty, castValue, checkCache, clone, compileCache, compileMatcher, compileState, createBatchedPoster, createDestination, createEvent, createIngest, createLogger, createMockContext, createMockLogger, createRespond, createTelemetryObserver, debounce, deepMerge, defaultClickIds, deleteByPath, deserializeStoreValue, emitStep, fetchPackage, fetchPackageSchema, filterValues, flattenIncludeSections, formatOut, getBrowser, getBrowserVersion, getByPath, getDeviceType, getEvent, getFlowSettings, getGrantedConsent, getHeaders, getId, getMappingEvent, getMappingValue, getMarketingParameters, getNextSteps, getOS, getOSVersion, getPlatform, getSpanId, getTraceId, getTraceUntil, isArguments, isArray, isBoolean, isCommand, isDefined, isElementOrDocument, isEnvObserve, isFunction, isNumber, isObject, isPathStepEntry, isPropertyType, isRouteArray, isRouteConfigEntry, isSameType, isSampled, isStoreValue, isString, mcpError, mcpResult, mergeContractSchemas, mergeMappingRule, mockEnv, observeFromEnv, packageNameToVariable, parseCallPath, parseGrant, parseObserveCredential, parseTraceparent, parseUserAgent, processEventMapping, readCacheEnvelope, requestToData, requestToParameter, resolveContracts, resolveSetup, resolveTelemetryOptions, scanFlowRefs, serializeStoreValue, setByPath, setTraceUntil, stepId, storeCache, throttle, throwError, transformData, traverseEnv, trim, tryCatch, tryCatchAsync, useHooks, validateStepEntry, verifyActivation, walkPath, wrapCacheEnvelope, wrapCondition, wrapFn, wrapValidate };
+export { type ActivationGrant, type AssembleJourneysOptions, type BatchResponse, type BatchedPosterOptions, type BreakerState, CLOCK_SKEW_MS, cache as Cache, type CacheEnvelope, type CacheResult, type ClickIdEntry, collector as Collector, type CompiledCache, Const, context as Context, type Credential, type Debounced, destination as Destination, type DestroyContext, type DestroyFn, type DroppedCounters, ENV_MARKER_PREFIX, elb as Elb, type EmitFn, type EventOutcome, type ExampleSummary, FatalError, Flow, type FlowConfigResolver, type FlowState, type FlowStateBatch, type FlowStatePhase, type FlowStepType, type GetStore, hint as Hint, hooks as Hooks, type Ingest, type IngestEnvelope, type IngestMeta, InvalidEventError, type Journey, type JourneyAssembly, type JourneyBranch, type JourneyCorrelation, type JourneyEntry, type JourneyGap, type JourneyHop, type JourneyHopStatus, type JourneyPlatform, type JourneyStatus, type JourneyTopology, type JourneyTopologyNode, type JourneyUnattributed, type JsonSchema, Level, lifecycle as Lifecycle, type LifecycleContext, logger as Logger, MAX_SESSION_MS, mapping as Mapping, type MarketingParameters, matcher as Matcher, type MockLogger, type NodeLikeRequest, OBSERVE_ENV_KEY, OBSERVE_STORAGE_KEY, type Observe, type ObserveCredential, type ObserveServer, type ObserveWeb, type ObserverFn, on as On, type ParsedGrant, type ParsedTraceparent, type PosterFetch, type PosterResponse, type PreviewCrypto, type PreviewFailure, type PreviewKey, type PreviewSubtle, REF_CODE_PREFIX, REF_CONTRACT, REF_ENV, REF_FLOW, REF_SECRET, REF_STORE, REF_VAR_FULL, REF_VAR_INLINE, request as Request, type ResolveContractsOptions, type ResolveOptions, type RespondFn, type RespondOptions, SECRET_MARKER_PREFIX, SESSION_STORAGE_KEY, STEP_OPERATIVE_FIELDS, type ScheduleOptions, type SendDataValue, type SendHeaders, type SendResponse, type ServiceAccount, type SetupFn, simulation as Simulation, source as Source, type State, type StepEntryErrorCode, type StepEntryValidation, type StepKind, type StorageType, store as Store, StoreCodecError, type SwapActivatorConfig, type TelemetryLevel, type TelemetryOptions, type TelemetryOptionsSupplier, transformer as Transformer, trigger as Trigger, URL_WINDOW_MS, type ValidateEvents, type VerifyParams, type VerifyResult, walkeros as WalkerOS, type WalkerOSPackage, type WalkerOSPackageInfo, type WalkerOSPackageMeta, anonymizeIP, applyState, applyUpdate, assembleJourneys, assign, batchResponse, branch, browserSwapActivator, buildCacheContext, buildScopeFromNodeRequest, castToProperty, castValue, checkCache, clone, compileCache, compileMatcher, compileState, createBatchedPoster, createDestination, createEvent, createIngest, createLogger, createMockContext, createMockLogger, createRespond, createTelemetryObserver, debounce, deepMerge, defaultClickIds, deleteByPath, deserializeStoreValue, emitStep, fetchPackage, fetchPackageSchema, filterValues, flattenIncludeSections, formatOut, getBrowser, getBrowserVersion, getByPath, getDeviceType, getEvent, getFlowSettings, getGrantedConsent, getHeaders, getId, getMappingEvent, getMappingValue, getMarketingParameters, getNextSteps, getOS, getOSVersion, getPlatform, getSpanId, getTraceId, getTraceUntil, isArguments, isArray, isBatchBody, isBoolean, isCommand, isDefined, isElementOrDocument, isEnvObserve, isFunction, isNumber, isObject, isPathStepEntry, isPropertyType, isRouteArray, isRouteConfigEntry, isSameType, isSampled, isScope, isStoreValue, isString, mcpError, mcpResult, mergeContractSchemas, mergeMappingRule, mockEnv, normalizeBody, normalizeHeaders, normalizeQuery, observeFromEnv, packageNameToVariable, parseCallPath, parseGrant, parseObserveCredential, parseTraceparent, parseUserAgent, processEventMapping, pushResultToOutcome, readCacheEnvelope, requestToData, requestToParameter, resolveContracts, resolveSetup, resolveTelemetryOptions, scanFlowRefs, serializeStoreValue, setByPath, setTraceUntil, stepId, storeCache, throttle, throwError, toEventList, transformData, traverseEnv, trim, tryCatch, tryCatchAsync, useHooks, validateStepEntry, verifyActivation, walkPath, wrapCacheEnvelope, wrapCondition, wrapFn, wrapValidate };