@walkeros/core 4.1.1-next-1779485810490 → 4.1.1

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # @walkeros/core
 
-## 4.1.1-next-1779485810490
+## 4.1.1
 
 ### Patch Changes
 
@@ -11,6 +11,13 @@
   partial rule onto a package-shipped default (a `null` value clears an
   inherited field); `remove` strips fields from the produced payload. Rules
   without either keyword keep the existing replace behavior.
+- 0b7f494: The collector exposes `observers: Set<ObserverFn>` so any subscriber
+  can watch every step of the pipeline. Each source, transformer, destination,
+  and store call emits a `FlowState` record with timings, mapping match, consent
+  state, and skip reasons. `createTelemetryObserver` from `@walkeros/core`
+  batches emissions to an HTTP endpoint, and the CLI runtime picks up the
+  `traceUntil` flag from its heartbeat so trace mode toggles take effect without
+  a redeploy.
 
 ## 4.1.0
 

package/dist/dev.d.mts

@@ -6868,6 +6868,74 @@ interface Ingest {
     _meta: IngestMeta;
 }
 
+/**
+ * FlowState is the canonical observation record emitted at each hop in a
+ * walkerOS pipeline. Telemetry helpers populate one of these per (step,
+ * phase) tuple and pass it to a user-supplied emit callback. The shape is
+ * stable across step kinds (source, transformer, collector, destination,
+ * store) so a single observer can correlate work across the pipeline.
+ *
+ * Optional fields are populated only when meaningful for the (step, phase)
+ * pair, or when the telemetry options explicitly opt in (e.g. trace level
+ * for inEvent/outEvent).
+ */
+type FlowStatePhase = 'init' | 'in' | 'out' | 'error' | 'skip' | 'flush';
+type FlowStepType = 'source' | 'transformer' | 'collector' | 'destination' | 'store';
+interface FlowStateBatch {
+    size: number;
+    index: number;
+}
+interface FlowState {
+    /** The flow this state belongs to. */
+    flowId: string;
+    /** Step identifier, e.g. 'destination.gtag', 'transformer.consent', 'collector.push'. */
+    stepId: string;
+    stepType: FlowStepType;
+    phase: FlowStatePhase;
+    /** W3C span-id of the originating WalkerOS.Event. Sourced from event.id; never synthesized. */
+    eventId: string;
+    /** ISO 8601 timestamp. */
+    timestamp: string;
+    /** Milliseconds since the runtime's startedAt origin. Monotonic. */
+    elapsedMs: number;
+    /** Wall-clock duration of this step, if measured (typically only on 'out'). */
+    durationMs?: number;
+    /** Inbound walker event for this hop. Only populated when level === 'trace' or includeIn === true. */
+    inEvent?: unknown;
+    /** Outbound walker event/payload for this hop. Only populated when level === 'trace' or includeOut === true. */
+    outEvent?: unknown;
+    /** Error info when phase === 'error'. */
+    error?: {
+        name?: string;
+        message: string;
+    };
+    /** The mapping rule that matched, when one matched. */
+    mappingKey?: string;
+    /** Contract rule that matched, if any. */
+    contractRule?: string;
+    /** Consent gate snapshot at hop time. */
+    consent?: Record<string, boolean>;
+    /** Consent state actually applied (after policy resolution). */
+    consentApplied?: Record<string, boolean>;
+    /** W3C 16-hex span-id of the child branch for `many` fan-out. */
+    branchId?: string;
+    /** For phase === 'flush', the batch size + entry index. */
+    batch?: FlowStateBatch;
+    /** Discriminator when phase === 'skip'. */
+    skipReason?: 'consent' | 'cache_hit' | 'sampled_out' | 'disabled' | 'unknown';
+    /** Free-form metadata: store key/value, cached: true, etc. */
+    meta?: Record<string, unknown>;
+}
+
+/**
+ * Pipeline observation channel. Observers receive a FlowState record per
+ * step phase (init, in, out, error, skip, flush) and run synchronously in
+ * the collector's emit loop. They must not throw; emitStep swallows
+ * thrown values defensively so a slow or buggy observer cannot crash the
+ * pipeline. Observers must not perform synchronous IO.
+ */
+type ObserverFn = (state: FlowState) => void;
+
 /**
  * Drop counters at a single step. Each buffer is optional: a step kind
  * may have only `queue` (collector), only `dlq`, both (destinations
@@ -7038,6 +7106,15 @@ interface Instance$5 {
     stores: Stores;
     globals: Properties;
     hooks: Functions;
+    /**
+     * First-class observation channel. The runtime self-emits FlowState
+     * records at canonical step sites (collector.push, destination.push,
+     * destination.init, destination.pushBatch, destination consent skip,
+     * transformer.push, store.get/set/delete, store cache HIT/MISS).
+     * Observers run synchronously inside emitStep; thrown values are
+     * swallowed. Subscribers add/remove via the standard Set API.
+     */
+    observers: Set<ObserverFn>;
     logger: Instance$3;
     on: OnConfig;
     queue: Events;
@@ -8248,6 +8325,29 @@ declare namespace Flow {
          * Consumed by the CLI bundler at build time.
          */
         bundle?: Bundle;
+        /**
+         * Observability configuration. Controls whether the runtime emits
+         * FlowState records to a remote observer, and at what verbosity.
+         *
+         * When omitted, the runtime defaults to `{ level: 'standard' }` for
+         * managed deployments. When `level: 'off'`, the bundle ships no
+         * telemetry plumbing at all.
+         */
+        observe?: Observe;
+    }
+    /**
+     * Observability configuration block.
+     *
+     * - `off` disables telemetry entirely (no hooks installed, no fetch).
+     * - `standard` emits structural FlowState records (no inEvent/outEvent).
+     * - `trace` emits full payloads on every hop. Use only for short debug
+     *   windows; the operator can also flip the deployment's `trace_until`
+     *   timestamp at runtime to enable trace without a redeploy.
+     */
+    interface Observe {
+        level?: 'off' | 'standard' | 'trace';
+        /** Deterministic sample fraction in [0, 1]. Defaults to 1. */
+        sample?: number;
     }
     /**
      * Reusable values referenced via `$var.name` (with optional deep paths).

package/dist/dev.d.ts

@@ -6868,6 +6868,74 @@ interface Ingest {
     _meta: IngestMeta;
 }
 
+/**
+ * FlowState is the canonical observation record emitted at each hop in a
+ * walkerOS pipeline. Telemetry helpers populate one of these per (step,
+ * phase) tuple and pass it to a user-supplied emit callback. The shape is
+ * stable across step kinds (source, transformer, collector, destination,
+ * store) so a single observer can correlate work across the pipeline.
+ *
+ * Optional fields are populated only when meaningful for the (step, phase)
+ * pair, or when the telemetry options explicitly opt in (e.g. trace level
+ * for inEvent/outEvent).
+ */
+type FlowStatePhase = 'init' | 'in' | 'out' | 'error' | 'skip' | 'flush';
+type FlowStepType = 'source' | 'transformer' | 'collector' | 'destination' | 'store';
+interface FlowStateBatch {
+    size: number;
+    index: number;
+}
+interface FlowState {
+    /** The flow this state belongs to. */
+    flowId: string;
+    /** Step identifier, e.g. 'destination.gtag', 'transformer.consent', 'collector.push'. */
+    stepId: string;
+    stepType: FlowStepType;
+    phase: FlowStatePhase;
+    /** W3C span-id of the originating WalkerOS.Event. Sourced from event.id; never synthesized. */
+    eventId: string;
+    /** ISO 8601 timestamp. */
+    timestamp: string;
+    /** Milliseconds since the runtime's startedAt origin. Monotonic. */
+    elapsedMs: number;
+    /** Wall-clock duration of this step, if measured (typically only on 'out'). */
+    durationMs?: number;
+    /** Inbound walker event for this hop. Only populated when level === 'trace' or includeIn === true. */
+    inEvent?: unknown;
+    /** Outbound walker event/payload for this hop. Only populated when level === 'trace' or includeOut === true. */
+    outEvent?: unknown;
+    /** Error info when phase === 'error'. */
+    error?: {
+        name?: string;
+        message: string;
+    };
+    /** The mapping rule that matched, when one matched. */
+    mappingKey?: string;
+    /** Contract rule that matched, if any. */
+    contractRule?: string;
+    /** Consent gate snapshot at hop time. */
+    consent?: Record<string, boolean>;
+    /** Consent state actually applied (after policy resolution). */
+    consentApplied?: Record<string, boolean>;
+    /** W3C 16-hex span-id of the child branch for `many` fan-out. */
+    branchId?: string;
+    /** For phase === 'flush', the batch size + entry index. */
+    batch?: FlowStateBatch;
+    /** Discriminator when phase === 'skip'. */
+    skipReason?: 'consent' | 'cache_hit' | 'sampled_out' | 'disabled' | 'unknown';
+    /** Free-form metadata: store key/value, cached: true, etc. */
+    meta?: Record<string, unknown>;
+}
+
+/**
+ * Pipeline observation channel. Observers receive a FlowState record per
+ * step phase (init, in, out, error, skip, flush) and run synchronously in
+ * the collector's emit loop. They must not throw; emitStep swallows
+ * thrown values defensively so a slow or buggy observer cannot crash the
+ * pipeline. Observers must not perform synchronous IO.
+ */
+type ObserverFn = (state: FlowState) => void;
+
 /**
  * Drop counters at a single step. Each buffer is optional: a step kind
  * may have only `queue` (collector), only `dlq`, both (destinations
@@ -7038,6 +7106,15 @@ interface Instance$5 {
     stores: Stores;
     globals: Properties;
     hooks: Functions;
+    /**
+     * First-class observation channel. The runtime self-emits FlowState
+     * records at canonical step sites (collector.push, destination.push,
+     * destination.init, destination.pushBatch, destination consent skip,
+     * transformer.push, store.get/set/delete, store cache HIT/MISS).
+     * Observers run synchronously inside emitStep; thrown values are
+     * swallowed. Subscribers add/remove via the standard Set API.
+     */
+    observers: Set<ObserverFn>;
     logger: Instance$3;
     on: OnConfig;
     queue: Events;
@@ -8248,6 +8325,29 @@ declare namespace Flow {
          * Consumed by the CLI bundler at build time.
          */
         bundle?: Bundle;
+        /**
+         * Observability configuration. Controls whether the runtime emits
+         * FlowState records to a remote observer, and at what verbosity.
+         *
+         * When omitted, the runtime defaults to `{ level: 'standard' }` for
+         * managed deployments. When `level: 'off'`, the bundle ships no
+         * telemetry plumbing at all.
+         */
+        observe?: Observe;
+    }
+    /**
+     * Observability configuration block.
+     *
+     * - `off` disables telemetry entirely (no hooks installed, no fetch).
+     * - `standard` emits structural FlowState records (no inEvent/outEvent).
+     * - `trace` emits full payloads on every hop. Use only for short debug
+     *   windows; the operator can also flip the deployment's `trace_until`
+     *   timestamp at runtime to enable trace without a redeploy.
+     */
+    interface Observe {
+        level?: 'off' | 'standard' | 'trace';
+        /** Deterministic sample fraction in [0, 1]. Defaults to 1. */
+        sample?: number;
     }
     /**
      * Reusable values referenced via `$var.name` (with optional deep paths).

package/dist/index.d.mts

@@ -220,6 +220,74 @@ interface Ingest {
 /** Create a fresh Ingest for a new pipeline invocation. */
 declare function createIngest(sourceId: string): Ingest;
 
+/**
+ * FlowState is the canonical observation record emitted at each hop in a
+ * walkerOS pipeline. Telemetry helpers populate one of these per (step,
+ * phase) tuple and pass it to a user-supplied emit callback. The shape is
+ * stable across step kinds (source, transformer, collector, destination,
+ * store) so a single observer can correlate work across the pipeline.
+ *
+ * Optional fields are populated only when meaningful for the (step, phase)
+ * pair, or when the telemetry options explicitly opt in (e.g. trace level
+ * for inEvent/outEvent).
+ */
+type FlowStatePhase = 'init' | 'in' | 'out' | 'error' | 'skip' | 'flush';
+type FlowStepType = 'source' | 'transformer' | 'collector' | 'destination' | 'store';
+interface FlowStateBatch {
+    size: number;
+    index: number;
+}
+interface FlowState {
+    /** The flow this state belongs to. */
+    flowId: string;
+    /** Step identifier, e.g. 'destination.gtag', 'transformer.consent', 'collector.push'. */
+    stepId: string;
+    stepType: FlowStepType;
+    phase: FlowStatePhase;
+    /** W3C span-id of the originating WalkerOS.Event. Sourced from event.id; never synthesized. */
+    eventId: string;
+    /** ISO 8601 timestamp. */
+    timestamp: string;
+    /** Milliseconds since the runtime's startedAt origin. Monotonic. */
+    elapsedMs: number;
+    /** Wall-clock duration of this step, if measured (typically only on 'out'). */
+    durationMs?: number;
+    /** Inbound walker event for this hop. Only populated when level === 'trace' or includeIn === true. */
+    inEvent?: unknown;
+    /** Outbound walker event/payload for this hop. Only populated when level === 'trace' or includeOut === true. */
+    outEvent?: unknown;
+    /** Error info when phase === 'error'. */
+    error?: {
+        name?: string;
+        message: string;
+    };
+    /** The mapping rule that matched, when one matched. */
+    mappingKey?: string;
+    /** Contract rule that matched, if any. */
+    contractRule?: string;
+    /** Consent gate snapshot at hop time. */
+    consent?: Record<string, boolean>;
+    /** Consent state actually applied (after policy resolution). */
+    consentApplied?: Record<string, boolean>;
+    /** W3C 16-hex span-id of the child branch for `many` fan-out. */
+    branchId?: string;
+    /** For phase === 'flush', the batch size + entry index. */
+    batch?: FlowStateBatch;
+    /** Discriminator when phase === 'skip'. */
+    skipReason?: 'consent' | 'cache_hit' | 'sampled_out' | 'disabled' | 'unknown';
+    /** Free-form metadata: store key/value, cached: true, etc. */
+    meta?: Record<string, unknown>;
+}
+
+/**
+ * Pipeline observation channel. Observers receive a FlowState record per
+ * step phase (init, in, out, error, skip, flush) and run synchronously in
+ * the collector's emit loop. They must not throw; emitStep swallows
+ * thrown values defensively so a slow or buggy observer cannot crash the
+ * pipeline. Observers must not perform synchronous IO.
+ */
+type ObserverFn = (state: FlowState) => void;
+
 /** Identifies which kind of step a stepId belongs to. */
 type StepKind = 'collector' | 'source' | 'transformer' | 'destination';
 /**
@@ -404,6 +472,15 @@ interface Instance$6 {
     stores: Stores$1;
     globals: Properties;
     hooks: Functions;
+    /**
+     * First-class observation channel. The runtime self-emits FlowState
+     * records at canonical step sites (collector.push, destination.push,
+     * destination.init, destination.pushBatch, destination consent skip,
+     * transformer.push, store.get/set/delete, store cache HIT/MISS).
+     * Observers run synchronously inside emitStep; thrown values are
+     * swallowed. Subscribers add/remove via the standard Set API.
+     */
+    observers: Set<ObserverFn>;
     logger: Instance$3;
     on: OnConfig;
     queue: Events;
@@ -1290,6 +1367,29 @@ declare namespace Flow {
          * Consumed by the CLI bundler at build time.
          */
         bundle?: Bundle;
+        /**
+         * Observability configuration. Controls whether the runtime emits
+         * FlowState records to a remote observer, and at what verbosity.
+         *
+         * When omitted, the runtime defaults to `{ level: 'standard' }` for
+         * managed deployments. When `level: 'off'`, the bundle ships no
+         * telemetry plumbing at all.
+         */
+        observe?: Observe;
+    }
+    /**
+     * Observability configuration block.
+     *
+     * - `off` disables telemetry entirely (no hooks installed, no fetch).
+     * - `standard` emits structural FlowState records (no inEvent/outEvent).
+     * - `trace` emits full payloads on every hop. Use only for short debug
+     *   windows; the operator can also flip the deployment's `trace_until`
+     *   timestamp at runtime to enable trace without a redeploy.
+     */
+    interface Observe {
+        level?: 'off' | 'standard' | 'trace';
+        /** Deterministic sample fraction in [0, 1]. Defaults to 1. */
+        sample?: number;
     }
     /**
      * Reusable values referenced via `$var.name` (with optional deep paths).
@@ -3406,18 +3506,193 @@ declare class FatalError extends Error {
  * A utility function that wraps a function with hooks.
  *
  * Pre/post hooks are user-supplied and may throw. A throwing hook must not
- * crash the surrounding pipeline — on failure, fall back to calling the
+ * crash the surrounding pipeline. On failure, fall back to calling the
  * original function (pre-hook) or keep the original result (post-hook).
  *
- * @template P, R
+ * The generic `F` preserves the exact call shape of `fn`, including named
+ * parameters and overloaded interfaces, so call sites can assign the result
+ * to the same interface slot without a cast.
+ *
+ * @template F The exact function type being wrapped.
  * @param fn The function to wrap.
  * @param name The name of the function.
  * @param hooks The hooks to use.
  * @param logger Optional logger for hook failure warnings. Falls back to
  *   `console.warn` when not provided.
- * @returns The wrapped function.
+ * @returns The wrapped function with the same call shape as `fn`.
+ */
+declare function useHooks<F extends AnyFunction$1>(fn: F, name: string, hooks: Functions, logger?: Instance$3): F;
+
+/**
+ * Telemetry level. Off disables emission entirely. Standard projects
+ * structural state without inEvent or outEvent payloads (unless explicitly
+ * opted in). Trace emits full payloads on every hop.
+ */
+type TelemetryLevel = 'off' | 'standard' | 'trace';
+/**
+ * Options that shape the telemetry projection strategy. Defaults are chosen
+ * so a caller can pass `{ flowId }` and get sensible behavior.
+ */
+interface TelemetryOptions {
+    /** Required flow identifier; observers may use this for cross-flow correlation. */
+    flowId: string;
+    /** Verbosity. Defaults to 'standard'. */
+    level?: TelemetryLevel;
+    /** Force-include the inbound event regardless of level. */
+    includeIn?: boolean;
+    /** Force-include the outbound event regardless of level. */
+    includeOut?: boolean;
+    /** Force-include the matched mapping key (only meaningful for transformers/destinations). */
+    includeMappingKey?: boolean;
+    /**
+     * Fraction of events to emit, between 0 and 1. Deterministic by eventId:
+     * the same eventId always falls on the same side of the threshold so
+     * paired in/out states either both emit or both drop.
+     */
+    sample?: number;
+}
+type EmitFn = (state: FlowState) => void;
+/**
+ * Optional supplier form. When passed instead of static `TelemetryOptions`,
+ * the observer evaluates the supplier on every emit so toggle-style runtime
+ * overrides (e.g. `WALKEROS_TRACE_UNTIL`) reach the projection without
+ * rebuilding the observer.
+ */
+type TelemetryOptionsSupplier = () => TelemetryOptions | null;
+/**
+ * Build a telemetry observer that projects FlowState records according to
+ * level/sample/include flags and forwards them to `emit`. The observer is
+ * synchronous, never throws (a throwing emit is swallowed), and does no
+ * IO of its own. Designed to be added to `collector.observers` so the
+ * runtime self-emission loop drives it.
+ *
+ * Accepts either a static `TelemetryOptions` value or a supplier
+ * `() => TelemetryOptions | null`. With a supplier, every emit reads the
+ * current opts so toggles such as `WALKEROS_TRACE_UNTIL` reach the
+ * projection without rebuilding the observer. A supplier returning `null`
+ * suppresses the emit (telemetry off).
+ */
+declare function createTelemetryObserver(emit: EmitFn, optsOrSupplier: TelemetryOptions | TelemetryOptionsSupplier): ObserverFn;
+/**
+ * Convenience export: the internal sampling predicate so callers (and
+ * tests) can verify the deterministic bucketing without importing the
+ * private FNV-1a helper.
+ */
+declare function isSampled(eventId: string, sample: number): boolean;
+
+/**
+ * Runtime telemetry resolver.
+ *
+ * Converts a flow-side `Flow.Config.observe` block plus a runtime override
+ * (the `WALKEROS_TRACE_UNTIL` env var) into a concrete `TelemetryOptions`
+ * the collector hooks installer can consume.
+ *
+ * Resolution order (highest priority first):
+ *   1. `WALKEROS_TRACE_UNTIL` env var, if present and parses to a future ISO
+ *      timestamp -> force level=trace, sample=1, include in/out payloads.
+ *   2. The `observe` block from `flow.config?.observe`.
+ *   3. A tier default of `{ level: 'standard' }`.
+ *
+ * The full poll-and-update plumbing that lets an operator flip
+ * `WALKEROS_TRACE_UNTIL` without redeploying the container is intentionally
+ * stubbed at the env-var seam: the deployment record's `trace_until` is
+ * written by the app, but a sidecar/heartbeat that propagates it into the
+ * container is out of scope for this phase. For now an operator sets the
+ * env var directly, or the next deploy picks it up at boot.
+ */
+
+interface ResolveTelemetryInput {
+    flowId: string;
+    /** From `flow.config?.observe`. May be undefined. */
+    observe?: {
+        level?: 'off' | 'standard' | 'trace';
+        sample?: number;
+    };
+    /** Snapshot of `process.env` (or any equivalent). Test seam. */
+    env?: Record<string, string | undefined>;
+    /** Clock seam for tests. Defaults to `Date.now()`. */
+    now?: () => number;
+}
+/**
+ * Returns `TelemetryOptions` ready to pass to `createTelemetryObserver`,
+ * or `null` if telemetry is disabled (`level === 'off'` with no trace
+ * override). Callers should skip observer installation when this returns
+ * null.
+ */
+declare function resolveTelemetryOptions(input: ResolveTelemetryInput): TelemetryOptions | null;
+
+/**
+ * Synchronously fans out a FlowState record to every registered observer
+ * on the collector. Each call is wrapped in try/catch so a misbehaving
+ * observer cannot crash the runtime; observers are advisory and must not
+ * affect pipeline outcomes.
+ *
+ * Iterates a snapshot of the observer set so an observer adding or removing
+ * another observer during the emit does not re-enter or skip in the same
+ * pass. The early return on an empty set keeps the zero-observer hot path
+ * allocation-free.
+ */
+declare function emitStep(collector: Instance$6, state: FlowState): void;
+
+/**
+ * Batched FlowState poster.
+ *
+ * Buffers FlowState records and flushes them to an HTTP endpoint either when
+ * `batchMs` elapses since the first queued record, or when `batchSize` is
+ * reached. Returns the emit callback that `createTelemetryObserver` consumes.
+ *
+ * Errors from the underlying fetch are swallowed (or routed through the
+ * optional `onError` callback) so a transient observer outage cannot crash
+ * the runtime.
+ *
+ * Uses the global `fetch` so the same primitive works in Node 18+, browsers,
+ * and Edge runtimes. Tests may inject a stub via `opts.fetch`.
+ */
+
+/**
+ * Minimum HTTP response surface the poster touches. Anything that exposes
+ * `ok` and `status` works. Decoupling from the DOM `Response` type lets the
+ * helper run in Edge, browser, and Node-only test environments without
+ * requiring `lib: dom` or a polyfill.
+ */
+interface PosterResponse {
+    ok: boolean;
+    status: number;
+}
+/**
+ * Minimum fetch surface the poster needs. A subset of `typeof fetch` that
+ * lets test harnesses pass a plain async function without dragging in the
+ * Response/Request DOM types.
+ */
+type PosterFetch = (url: string, init: {
+    method: string;
+    headers: Record<string, string>;
+    body: string;
+}) => Promise<PosterResponse>;
+interface BatchedPosterOptions {
+    /** Absolute HTTP endpoint URL. POST with JSON array body. */
+    url: string;
+    /** Bearer token sent in the `Authorization` header. */
+    token: string;
+    /** Max time to wait before flushing the current batch. Default 50 ms. */
+    batchMs?: number;
+    /** Max records per batch. When reached, flushes immediately. Default 50. */
+    batchSize?: number;
+    /** Test seam. Defaults to the global `fetch`. */
+    fetch?: PosterFetch;
+    /** Called when the underlying POST rejects. Defaults to swallowing. */
+    onError?: (err: unknown) => void;
+}
+/**
+ * Build a batched emit callback. The returned function is synchronous, never
+ * throws, and schedules an async flush in the background.
+ *
+ * Concurrency model: a single in-memory buffer plus a single pending timer.
+ * When the timer fires (or `batchSize` is hit) the buffer is moved into a
+ * local variable and reset, then POSTed. New records arriving during the in-
+ * flight POST land in the next batch.
  */
-declare function useHooks<P extends unknown[], R>(fn: (...args: P) => R, name: string, hooks: Functions, logger?: Instance$3): (...args: P) => R;
+declare function createBatchedPoster(opts: BatchedPosterOptions): (state: FlowState) => void;
 
 /**
  * Parses a user agent string to extract browser, OS, and device information.
@@ -3714,4 +3989,4 @@ 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, Const, context as Context, type Debounced, destination as Destination, type DestroyContext, type DestroyFn, type DroppedCounters, ENV_MARKER_PREFIX, elb as Elb, type ExampleSummary, FatalError, Flow, type FlowConfigResolver, hint as Hint, hooks as Hooks, type Ingest, type IngestMeta, type JsonSchema, Level, lifecycle as Lifecycle, type LifecycleContext, logger as Logger, mapping as Mapping, type MarketingParameters, matcher as Matcher, type MockLogger, on as On, REF_CODE_PREFIX, REF_CONTRACT, REF_ENV, REF_FLOW, REF_SECRET, REF_STORE, REF_VAR_FULL, REF_VAR_INLINE, request as Request, type ResolveOptions, type RespondFn, type RespondOptions, STEP_OPERATIVE_FIELDS, type ScheduleOptions, type SendDataValue, type SendHeaders, type SendResponse, type SetupFn, simulation as Simulation, source as Source, type StepEntryErrorCode, type StepEntryValidation, type StepKind, type StorageType, store as Store, transformer as Transformer, trigger as Trigger, type Validate, type ValidateEvents, walkeros as WalkerOS, type WalkerOSPackage, type WalkerOSPackageInfo, type WalkerOSPackageMeta, anonymizeIP, applyUpdate, assign, branch, buildCacheContext, castToProperty, castValue, checkCache, clone, compileCache, compileMatcher, createDestination, createEvent, createIngest, createLogger, createMockContext, createMockLogger, createRespond, debounce, deepMerge, defaultClickIds, deleteByPath, fetchPackage, fetchPackageSchema, filterValues, flattenIncludeSections, formatOut, getBrowser, getBrowserVersion, getByPath, getDeviceType, getEvent, getFlowSettings, getGrantedConsent, getHeaders, getId, getMappingEvent, getMappingValue, getMarketingParameters, getNextSteps, getOS, getOSVersion, getPlatform, getSpanId, isArguments, isArray, isBoolean, isCommand, isDefined, isElementOrDocument, isFunction, isNumber, isObject, isPathStepEntry, isPropertyType, isSameType, isString, mcpError, mcpResult, mergeContractSchemas, mergeMappingRule, mockEnv, packageNameToVariable, parseUserAgent, processEventMapping, requestToData, requestToParameter, resolveContracts, resolveSetup, setByPath, stepId, storeCache, throttle, throwError, transformData, traverseEnv, trim, tryCatch, tryCatchAsync, useHooks, validateStepEntry, walkPath, wrapCondition, wrapFn, wrapValidate };
+export { type BatchedPosterOptions, cache as Cache, type CacheResult, type ClickIdEntry, collector as Collector, type CompiledCache, Const, context as Context, 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, hint as Hint, hooks as Hooks, type Ingest, type IngestMeta, type JsonSchema, Level, lifecycle as Lifecycle, type LifecycleContext, logger as Logger, mapping as Mapping, type MarketingParameters, matcher as Matcher, type MockLogger, type ObserverFn, on as On, type PosterFetch, type PosterResponse, REF_CODE_PREFIX, REF_CONTRACT, REF_ENV, REF_FLOW, REF_SECRET, REF_STORE, REF_VAR_FULL, REF_VAR_INLINE, request as Request, type ResolveOptions, type RespondFn, type RespondOptions, STEP_OPERATIVE_FIELDS, type ScheduleOptions, type SendDataValue, type SendHeaders, type SendResponse, type SetupFn, simulation as Simulation, source as Source, type StepEntryErrorCode, type StepEntryValidation, type StepKind, type StorageType, store as Store, type TelemetryLevel, type TelemetryOptions, type TelemetryOptionsSupplier, transformer as Transformer, trigger as Trigger, type Validate, type ValidateEvents, walkeros as WalkerOS, type WalkerOSPackage, type WalkerOSPackageInfo, type WalkerOSPackageMeta, anonymizeIP, applyUpdate, assign, branch, buildCacheContext, castToProperty, castValue, checkCache, clone, compileCache, compileMatcher, createBatchedPoster, createDestination, createEvent, createIngest, createLogger, createMockContext, createMockLogger, createRespond, createTelemetryObserver, debounce, deepMerge, defaultClickIds, deleteByPath, emitStep, fetchPackage, fetchPackageSchema, filterValues, flattenIncludeSections, formatOut, getBrowser, getBrowserVersion, getByPath, getDeviceType, getEvent, getFlowSettings, getGrantedConsent, getHeaders, getId, getMappingEvent, getMappingValue, getMarketingParameters, getNextSteps, getOS, getOSVersion, getPlatform, getSpanId, isArguments, isArray, isBoolean, isCommand, isDefined, isElementOrDocument, isFunction, isNumber, isObject, isPathStepEntry, isPropertyType, isSameType, isSampled, isString, mcpError, mcpResult, mergeContractSchemas, mergeMappingRule, mockEnv, packageNameToVariable, parseUserAgent, processEventMapping, requestToData, requestToParameter, resolveContracts, resolveSetup, resolveTelemetryOptions, setByPath, stepId, storeCache, throttle, throwError, transformData, traverseEnv, trim, tryCatch, tryCatchAsync, useHooks, validateStepEntry, walkPath, wrapCondition, wrapFn, wrapValidate };