@v-tilt/browser 1.11.0 → 1.13.0

package/dist/config.d.ts

@@ -3,7 +3,14 @@ export declare class ConfigManager {
     private config;
     constructor(config?: Partial<VTiltConfig>);
     /**
-     * Parse configuration from script attributes
+     * Parse configuration from script attributes.
+     *
+     * IMPORTANT: do not back-fill `log_level` with a resolved default here.
+     * `log_level` in VTiltConfig represents the integrator's explicit intent —
+     * `setLevelFromConfig` (logger.ts) treats `log_level !== undefined` as
+     * "integrator pinned the level", which then locks remote /decide overrides.
+     * Baking in `'warn'` for every integrator who didn't pass anything would
+     * silently disable dashboard-driven log-level changes via diagnostics.
      */
     private parseConfigFromScript;
     /**

package/dist/constants.d.ts

@@ -57,14 +57,6 @@ export declare const PERSISTENCE_METHODS: {
     sessionStorage: "sessionStorage";
     memory: "memory";
 };
-/** @deprecated Use PERSISTENCE_METHODS instead */
-export declare const STORAGE_METHODS: {
-    cookie: "cookie";
-    localStorage: "localStorage";
-    localStoragePlusCookie: "localStorage+cookie";
-    sessionStorage: "sessionStorage";
-    memory: "memory";
-};
 /** Enable person processing flag */
 export declare const ENABLE_PERSON_PROCESSING = "$epp";
 /** Initial person info (referrer, URL, UTM params) */
@@ -87,23 +79,25 @@ export declare const EVENT_PAGELEAVE = "$pageleave";
 /** Identify event */
 export declare const EVENT_IDENTIFY = "$identify";
 /** Alias event */
-export declare const EVENT_ALIAS = "$create_alias";
+export declare const EVENT_ALIAS = "$alias";
 /** Set person properties event */
 export declare const EVENT_SET = "$set";
-/** Group identify event */
-export declare const EVENT_GROUP_IDENTIFY = "$groupidentify";
 /** Performance event */
 export declare const EVENT_PERFORMANCE = "$performance_event";
+/** Autocapture event */
+export declare const EVENT_AUTOCAPTURE = "$autocapture";
+/** Scroll depth milestone event (autocapture) */
+export declare const EVENT_SCROLL_DEPTH = "$scroll_depth";
 /** Snapshot event (session recording) */
 export declare const EVENT_SNAPSHOT = "$snapshot";
+/** Snapshot batch items event */
+export declare const EVENT_SNAPSHOT_ITEMS = "$snapshot_items";
 /** Rate limit warning event */
 export declare const EVENT_RATE_LIMIT_WARNING = "$$client_ingestion_warning";
 /** Process person profile flag */
 export declare const PROP_PROCESS_PERSON_PROFILE = "$process_person_profile";
 /** Is identified flag */
 export declare const PROP_IS_IDENTIFIED = "$is_identified";
-/** Anonymous distinct ID */
-export declare const PROP_ANON_DISTINCT_ID = "$anon_distinct_id";
 /** Session ID property */
 export declare const PROP_SESSION_ID = "$session_id";
 /** Window ID property */
@@ -114,6 +108,18 @@ export declare const PROP_CURRENT_URL = "$current_url";
 export declare const PROP_HOST = "$host";
 /** Pathname */
 export declare const PROP_PATHNAME = "$pathname";
+/** Seconds on the page being left ($pageleave) */
+export declare const PROP_PREV_PAGEVIEW_DURATION = "$prev_pageview_duration";
+/** Pathname of the page being left */
+export declare const PROP_PREV_PAGEVIEW_PATHNAME = "$prev_pageview_pathname";
+/** URL of the page being left */
+export declare const PROP_PREV_PAGEVIEW_URL = "$prev_pageview_url";
+/** Scroll depth milestone threshold (0–100) */
+export declare const PROP_SCROLL_DEPTH_PCT = "$scroll_depth_pct";
+/** Max scroll depth % at time of milestone event */
+export declare const PROP_SCROLL_DEPTH_MAX_PCT = "$scroll_depth_max_pct";
+/** Max scroll depth % on the page being left ($pageleave) */
+export declare const PROP_PREV_PAGEVIEW_SCROLL_DEPTH_PCT = "$prev_pageview_scroll_depth_pct";
 /** Referrer URL */
 export declare const PROP_REFERRER = "$referrer";
 /** Referring domain */

package/dist/core/capture.d.ts

@@ -15,21 +15,31 @@ export interface CaptureHost {
         setSessionId(): void;
         getSessionId(): string | null;
         getWindowId(): string;
+        consumeSessionStart(): boolean;
     };
     userManager: {
         getAnonymousId(): string;
         getDistinctId(): string | null;
         getUserProperties(): Record<string, any>;
         get_initial_props(): Record<string, any>;
+        consumeFirstVisit(): boolean;
+    };
+    consentManager?: {
+        hasConsent(): boolean;
+        getConsentProperties(): Record<string, boolean>;
     };
     rateLimiter: {
         shouldAllowEvent(): boolean;
     };
-    sendRequest(url: string, event: TrackingEvent, shouldEnqueue?: boolean): void;
+    sendRequest(url: string, event: TrackingEvent): void;
+    bufferEvent(name: string, url: string, event: TrackingEvent): void;
     buildUrl(): string;
+    buildEndpointUrl(path: string): string;
 }
 export interface CaptureOptions {
     skip_client_rate_limiting?: boolean;
+    /** When true, do not add inter-capture engagement_time_msec (e.g. $pageleave uses dwell). */
+    skip_engagement?: boolean;
 }
 export declare class CaptureManager {
     private _host;
@@ -37,6 +47,7 @@ export declare class CaptureManager {
     private _initial_pageview_captured;
     private _visibility_state_listener;
     private _vt_person_id;
+    private readonly _pageLifecycle;
     constructor(host: CaptureHost);
     /** Set the vt person ID from URL parameter */
     setVtPersonId(id: string | null): void;
@@ -54,15 +65,14 @@ export declare class CaptureManager {
      * Used for system events like rate limit warnings.
      */
     captureInternal(name: string, payload: EventPayload): void;
-    /**
-     * Track a custom event (alias for capture).
-     */
-    trackEvent(name: string, payload?: EventPayload): void;
     /**
      * Capture initial pageview with visibility check.
      * Waits for page to become visible before capturing.
      */
     captureInitialPageview(): void;
+    tryCapturePageleave(reason: string, extraProps?: EventPayload): void;
+    resetPageleaveDedupe(): void;
+    private _isDebugMode;
     /**
      * Build enriched event payload with all common properties.
      */

package/dist/core/config-utils.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Resolved config helpers (VTiltConfig may contain sentinel values like
+ * `if_capture_pageview` that are not booleans until interpreted).
+ */
+import type { VTiltConfig } from "../types";
+/**
+ * Whether automatic $pageleave should run.
+ * - `capture_pageleave === false` → off
+ * - `capture_pageleave === true` → on
+ * - `undefined` or `'if_capture_pageview'` → on iff pageviews are enabled
+ *
+ * Server-side $config_pending filter handles the edge case where events
+ * are captured before fresh remote config loads.
+ */
+export declare function isPageleaveEnabled(config: VTiltConfig): boolean;

package/dist/core/consent.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Consent Manager
+ *
+ * Manages user consent state for analytics, marketing, and advertising.
+ * Stores consent in a first-party cookie (_vtilt_consent) and provides
+ * consent properties to attach to every event.
+ *
+ * When `requireConsent` is true in config, the CaptureManager gates
+ * non-essential events until setConsent() is called.
+ */
+export interface ConsentState {
+    analytics?: boolean;
+    marketing?: boolean;
+    advertising?: boolean;
+}
+export interface ConsentHost {
+    _emitter?: {
+        emit(event: string, payload?: unknown): void;
+    };
+    getConfig(): {
+        require_consent?: boolean;
+    };
+}
+export declare class ConsentManager {
+    private _host;
+    private _state;
+    private _hasBeenSet;
+    constructor(host: ConsentHost);
+    /**
+     * Set consent state. Merges with existing state.
+     * Persists to cookie and emits consent:updated.
+     */
+    setConsent(consent: ConsentState): void;
+    /**
+     * Get current consent state.
+     * Returns undefined fields for categories not yet set.
+     */
+    getConsent(): ConsentState;
+    /**
+     * Whether setConsent() has been called (or consent was loaded from cookie).
+     * Used by CaptureManager to gate events when requireConsent is true.
+     */
+    hasConsent(): boolean;
+    /**
+     * Apply default-all-granted state when no explicit consent exists.
+     * Sets all categories to true in memory but does NOT persist to cookie
+     * (implicit defaults don't need storage — only explicit user choices do).
+     */
+    setDefaultGranted(): void;
+    /**
+     * Returns event properties to attach to every captured event.
+     * Only includes fields that have been explicitly set.
+     */
+    getConsentProperties(): Record<string, boolean>;
+    /**
+     * Reset consent state (e.g. on user logout).
+     */
+    reset(): void;
+    private _readFromCookie;
+    private _writeToCookie;
+    private _removeCookie;
+}

package/dist/core/event-buffer.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Event Buffer
+ *
+ * Buffers events until fresh remote config is resolved. Ensures every
+ * event respects current project config.
+ *
+ * Ready condition:
+ *  - _configReady: fresh /api/d response applied (or fetch failed)
+ *
+ * When config IS ready, queued events are filtered against the resolved
+ * analytics toggles (capture_pageview, capture_pageleave, etc.) and
+ * dropped if disabled — mirroring the server-side $config_pending filter.
+ *
+ * Events that flush before config is ready (safety timeout, page unload)
+ * are tagged with $config_pending for server-side filtering.
+ */
+import type { TrackingEvent, VTiltConfig } from "../types";
+export interface BufferedEvent {
+    name: string;
+    url: string;
+    event: TrackingEvent;
+}
+export interface EventBufferHost {
+    sendRequest(url: string, event: TrackingEvent): void;
+    requestQueue: {
+        flush(): void;
+    };
+    getConfig(): VTiltConfig;
+}
+export declare class EventBuffer {
+    private _host;
+    private readonly _queue;
+    private _ready;
+    private _configReady;
+    private _safetyTimer;
+    constructor(host: EventBufferHost);
+    /**
+     * Push an event into the buffer.
+     * If ready, processes inline (pass-through). Otherwise queues.
+     */
+    push(item: BufferedEvent): void;
+    /** Signal that fresh remote config has been loaded (or fetch failed). */
+    markConfigReady(): void;
+    /**
+     * Force-flush all buffered events (page unload / safety timeout).
+     * Tags events with $config_pending when config hasn't loaded.
+     */
+    forceFlush(): void;
+    private _checkReady;
+    private _tryFlush;
+    private _flush;
+    private _process;
+    /**
+     * Check whether the event should be dropped based on resolved config.
+     * Mirrors the server-side checkProjectConfigFilter logic.
+     */
+    private _isDisabledByConfig;
+    private _tagConfigPending;
+    private _clearSafetyTimer;
+}

package/dist/core/fb-cookies.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Facebook Cookie Manager
+ *
+ * Manages _fbp (Facebook Browser ID) and _fbc (Facebook Click ID) cookies
+ * as first-party cookies for server-side Facebook CAPI integration.
+ *
+ * _fbp format: fb.1.{creation_timestamp_ms}.{random_10_digits}
+ *   - Set on first visit, 180-day expiry (Meta spec)
+ *
+ * _fbc format: fb.1.{click_timestamp_ms}.{fbclid}
+ *   - Set when fbclid URL parameter is present, 90-day expiry (Meta spec)
+ *   - Persisted so CAPI events carry the correct click timestamp
+ */
+/**
+ * Initialize Facebook cookies on SDK boot.
+ * - Generates _fbp if missing
+ * - Persists _fbc from fbclid URL parameter if present
+ */
+export declare function initFacebookCookies(): void;
+/**
+ * Read the current _fbp cookie value.
+ */
+export declare function getFbp(): string | undefined;
+/**
+ * Read the current _fbc cookie value.
+ */
+export declare function getFbc(): string | undefined;
+/**
+ * Remove both _fbp and _fbc cookies.
+ * Called when advertising consent is revoked.
+ */
+export declare function removeFacebookCookies(): void;

package/dist/core/feature-manager.d.ts

@@ -1,95 +1,87 @@
 /**
  * Feature Manager
  *
- * Handles feature initialization, lifecycle management, and configuration
- * updates for all SDK features (HistoryAutocapture, Autocapture,
- * SessionRecording, Chat).
+ * Central registry for SDK features. Features self-describe via descriptors
+ * that declare their config keys, remote config mappings, and class references.
+ *
+ * Responsibilities:
+ * - Registration: features register descriptors before init
+ * - Instance creation: createInstances() constructs instances during init() (pre-boot)
+ * - Starting: initAll() starts created instances at boot via startIfEnabled
+ * - Config propagation: notifyAll() calls onConfigUpdate on each instance
+ * - Descriptor exposure: getDescriptors() lets RemoteConfigManager._apply iterate
+ *
+ * @see docs/patterns/tracker-feature-lifecycle.md
  */
-import { VTiltConfig, RemoteConfig } from "../types";
+import type { VTiltConfig } from "../types";
 import type { Feature } from "../feature";
 /**
- * Interface for a feature class that can be instantiated.
+ * Self-describing metadata for a feature.
+ * Declared once at registration time; used by FeatureManager and RemoteConfigManager.
  */
-export interface FeatureClass<T extends Feature = Feature> {
-    new (host: any, config?: any): T;
-    extractConfig?(config: VTiltConfig): any;
-}
-/**
- * Feature registration entry
- */
-export interface FeatureEntry<T extends Feature = Feature> {
+export interface FeatureDescriptor {
+    /** Unique name (used as map key and for get()) */
     name: string;
-    instance?: T;
-    FeatureClass: FeatureClass<T>;
-    /** Whether the feature is in extensions folder (optional/lazy) */
-    isExtension?: boolean;
-    /** Config key to check for disabled state */
+    /** VTiltConfig key that holds this feature's config (e.g. "session_recording") */
+    configKey?: keyof VTiltConfig;
+    /** VTiltConfig boolean key that hard-disables the feature (e.g. "disable_session_recording") */
     disableKey?: keyof VTiltConfig;
-    /** Config key that controls enabled state (e.g., 'autocapture') */
-    enableKey?: keyof VTiltConfig;
+    /** Remote config mapping — tells _apply how to extract config from RemoteConfig */
+    remoteConfig?: {
+        /** Key on the RemoteConfig object (e.g. "sessionRecording") */
+        key: string;
+        /** Transform remote section into the shape written to VTiltConfig[configKey] */
+        map: (remote: Record<string, unknown>) => Record<string, unknown>;
+    };
+    /** Feature class — must have a static extractConfig and a constructor */
+    FeatureClass: {
+        new (instance: any, config?: any): Feature;
+        extractConfig(config: VTiltConfig): any;
+    };
 }
 /**
- * Interface for the VTilt instance methods needed by FeatureManager.
+ * Minimal host interface to avoid circular dependency with VTilt.
  */
 export interface FeatureHost {
     getConfig(): VTiltConfig;
 }
 export declare class FeatureManager {
     private _host;
-    private _features;
-    private _onFeatureStarted?;
-    private _onFeatureStopped?;
+    private _descriptors;
+    private _instances;
     constructor(host: FeatureHost);
-    /** Set callback for when a feature starts */
-    onFeatureStarted(callback: (name: string) => void): void;
-    /** Set callback for when a feature stops */
-    onFeatureStopped(callback: (name: string) => void): void;
+    /** Register a feature descriptor. Call before initAll(). */
+    register(desc: FeatureDescriptor): void;
     /**
-     * Register a feature class for management.
+     * Create instances for all registered features without starting them.
+     * Safe to call before DOM boot — constructors are lightweight.
+     * Idempotent: skips features that already have an instance.
+     *
+     * Hard-disabled features are skipped (instance not created):
+     * - `disableKey` is true (e.g. `disable_chat: true`)
+     * - `configKey` section has `enabled: false` (e.g. `chat: { enabled: false }`)
      */
-    register<T extends Feature>(entry: FeatureEntry<T>): void;
+    createInstances(): void;
     /**
-     * Get a feature instance by name.
-     */
-    get<T extends Feature>(name: string): T | undefined;
-    /**
-     * Initialize all registered features.
+     * Create and start all registered features.
+     * Calls `createInstances()` first (idempotent), then `startIfEnabled()` on each.
      */
     initAll(): void;
+    /** Notify all initialized features of a config change. */
+    notifyAll(config: VTiltConfig): void;
+    /** Get a feature instance by name. */
+    get<T extends Feature>(name: string): T | undefined;
+    /** Register a late-created feature instance (e.g. from a public start*() call). */
+    set(name: string, instance: Feature): void;
+    /** Expose descriptors so RemoteConfigManager._apply can iterate for remote config mapping. */
+    getDescriptors(): Map<string, FeatureDescriptor>;
     /**
-     * Initialize a specific feature by name.
-     */
-    init(name: string): Feature | undefined;
-    /**
-     * Start a feature manually by name.
-     */
-    start(name: string): void;
-    /**
-     * Stop a feature by name.
-     */
-    stop(name: string): void;
-    /**
-     * Check if a feature is active.
-     */
-    isActive(name: string): boolean;
-    /**
-     * Notify all features of configuration update.
-     */
-    notifyConfigUpdate(config: VTiltConfig): void;
-    /**
-     * Notify all features of remote configuration update.
-     */
-    notifyRemoteConfig(remote: RemoteConfig): void;
-    /**
-     * Get all feature instances.
-     */
-    getAll(): Feature[];
-    /**
-     * Initialize a single feature.
+     * True when the integrator explicitly hard-disabled this feature in code config.
+     * Two signals: `disableKey` flag (e.g. `disable_chat: true`) or
+     * `configKey` section with `enabled: false` (e.g. `chat: { enabled: false }`).
+     *
+     * When `enabled` is omitted (undefined), the feature may still auto-configure
+     * from dashboard settings, so we must construct the instance.
      */
-    private _initFeature;
+    private _isHardDisabled;
 }
-/**
- * Create and configure a FeatureManager with standard vTilt features.
- */
-export declare function createFeatureManager(host: FeatureHost): FeatureManager;

package/dist/core/fifo-queue.d.ts

@@ -0,0 +1,23 @@
+/**
+ * In-memory FIFO used by transport layers that must not drop ordering
+ * (EventBuffer, GoogleTagGateway pending captures).
+ *
+ * - Optional capacity: when full, {@link FifoQueue.enqueue} returns false
+ *   and the item is not stored (same semantics as the previous hand-rolled
+ *   `length < max` checks).
+ * - Default capacity is unbounded (`Number.POSITIVE_INFINITY`).
+ */
+export declare class FifoQueue<T> {
+    private readonly _maxItems;
+    private _items;
+    constructor(_maxItems?: number);
+    get length(): number;
+    /** Append one item when under capacity. */
+    enqueue(item: T): boolean;
+    /**
+     * Atomically remove every item in arrival order. Returns a new array
+     * reference owned by the caller; the queue is empty after this call.
+     */
+    takeAll(): T[];
+    clear(): void;
+}

package/dist/core/identity.d.ts

@@ -1,74 +1,64 @@
 /**
  * Identity Manager
  *
- * Handles user identification, property management, and alias creation.
- * Provides high-level identity operations that coordinate between
- * UserManager and event capture.
+ * Orchestrates user identification, property updates, and alias creation.
+ * All state lives in UserManager; this layer owns validation, dedup,
+ * event capture, and lifecycle events.
  */
-import { EventPayload } from "../types";
+import type { EventPayload, IdentityUpdate } from "../types";
 /**
- * Interface for the VTilt instance methods needed by IdentityManager.
- * Using a minimal interface avoids circular dependency.
+ * Minimal interface for the VTilt host.
+ * Avoids circular dependency while giving IdentityManager access to
+ * capture, user state reads, batched writes, session reset, and events.
  */
 export interface IdentityHost {
     capture(name: string, payload: EventPayload): void;
     userManager: {
         getDistinctId(): string | null;
-        setDistinctId(id: string): void;
         getAnonymousId(): string;
         getDeviceId(): string;
-        ensureDeviceId(id: string): void;
         getUserState(): "anonymous" | "identified";
-        setUserState(state: "anonymous" | "identified"): void;
         getUserIdentity(): Record<string, any>;
         getUserProperties(): Record<string, any>;
-        updateUserProperties(set?: Record<string, any>, setOnce?: Record<string, any>): void;
-        setUserProperties(set?: Record<string, any>, setOnce?: Record<string, any>): boolean;
-        isDistinctIdStringLikePublic(id: string): boolean;
-        createAlias(alias: string, original?: string): {
-            distinct_id: string;
-            original: string;
-        } | null;
+        applyUpdate(update: IdentityUpdate): void;
         reset(resetDeviceId?: boolean): void;
     };
     sessionManager: {
         resetSessionId(): void;
     };
     _emitter?: {
-        emit(event: string, payload?: any): void;
+        emit(event: string, payload?: unknown): void;
     };
 }
 export declare class IdentityManager {
     private _host;
+    private _lastIdentifyHash;
+    private _lastSetPropertiesHash;
     constructor(host: IdentityHost);
     /**
-     * Identify a user with property operations.
-     * Sends $identify event when transitioning from anonymous to identified.
+     * Identify a user.
      *
-     * @param newDistinctId - User's unique identifier
-     * @param userPropertiesToSet - Properties to set (can be updated)
-     * @param userPropertiesToSetOnce - Properties to set once (preserves first value)
+     * - Anonymous → identified: sends $identify (merge), persists after capture.
+     * - Already identified, different user: sends $identify (re-identify).
+     * - Same user, new properties only: delegates to setUserProperties.
+     * - Identical consecutive calls are deduplicated (React re-render safety).
      */
     identify(newDistinctId?: string, userPropertiesToSet?: Record<string, any>, userPropertiesToSetOnce?: Record<string, any>): void;
     /**
      * Set user properties without changing identity.
+     * Dedup mirrors identify: identical consecutive calls are skipped.
      */
     setUserProperties(userPropertiesToSet?: Record<string, any>, userPropertiesToSetOnce?: Record<string, any>): void;
     /**
-     * Reset user identity (logout).
-     * Clears all user data, generates new anonymous ID, resets session.
-     *
-     * @param reset_device_id - If true, also resets device_id
+     * Reset identity (logout).
+     * Clears user data, generates new anonymous ID, resets session.
      */
-    resetUser(reset_device_id?: boolean): void;
+    resetUser(resetDeviceId?: boolean): void;
     /**
-     * Create an alias to link two distinct IDs.
-     * Links anonymous session to account on signup.
-     *
-     * @param alias - A unique identifier that you want to use for this user
-     * @param original - The current identifier being used (optional)
+     * Create an alias linking two distinct IDs.
+     * If alias matches current identity, falls back to identify().
      */
-    createAlias(alias: string, original?: string): void;
+    alias(alias: string, original?: string): void;
     getUserIdentity(): Record<string, any>;
     getDeviceId(): string;
     getUserState(): "anonymous" | "identified";

package/dist/core/index.d.ts

@@ -10,4 +10,10 @@
 export { RemoteConfigManager, type RemoteConfigHost, type RemoteConfigCallback, } from "./remote-config";
 export { CaptureManager, type CaptureHost, type CaptureOptions, } from "./capture";
 export { IdentityManager, type IdentityHost } from "./identity";
-export { FeatureManager, createFeatureManager, type FeatureHost, type FeatureEntry, type FeatureClass, } from "./feature-manager";
+export { ConsentManager, type ConsentHost, type ConsentState } from "./consent";
+export { initFacebookCookies, removeFacebookCookies, getFbp, getFbc, } from "./fb-cookies";
+export { FeatureManager, type FeatureHost, type FeatureDescriptor, } from "./feature-manager";
+export { isPageleaveEnabled } from "./config-utils";
+export { PageLifecycleTracker } from "./page-lifecycle";
+export { EventBuffer, type EventBufferHost, type BufferedEvent, } from "./event-buffer";
+export { FifoQueue } from "./fifo-queue";

package/dist/core/page-lifecycle.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Page context, dwell time, and inter-event engagement for GA4-style metrics.
+ */
+import type { EventPayload } from "../types";
+import type { VTiltConfig } from "../types";
+export interface PageleaveCaptureFn {
+    (name: string, payload: EventPayload, options?: {
+        skip_engagement?: boolean;
+    }): void;
+}
+/**
+ * Tracks time on current URL and milliseconds since last capture for engagement_time_msec.
+ */
+export declare class PageLifecycleTracker {
+    private _pageEnterPerf;
+    /** Null until first engagement-consuming event; then wall clock for next delta */
+    private _lastCapturePerf;
+    private readonly _bootPerf;
+    private _prevUrl;
+    private _prevPathname;
+    private _prevTitle;
+    /** Dedupe pagehide + visibility hidden for the same page */
+    private _leaveEmittedForPageKey;
+    /**
+     * Call after a $pageview is sent (initial or SPA) to reset dwell timer and snapshot.
+     */
+    onAfterPageview(): void;
+    /**
+     * Milliseconds since last capture (or since boot on the first event). Does not advance the clock.
+     */
+    peekEngagementSinceLastCaptureMs(): number;
+    /** Call after a capture is enqueued so the next peek measures from this point. */
+    commitCaptureClock(): void;
+    private _pageKey;
+    /** Call when the tab becomes visible again so a later hide can emit another $pageleave. */
+    clearLeaveDedupe(): void;
+    /**
+     * Fire $pageleave if enabled and not already emitted for this page.
+     */
+    tryCapturePageleave(config: VTiltConfig, capture: PageleaveCaptureFn, reason: string, extraProps?: EventPayload): void;
+}