@v-tilt/browser 1.10.10 → 1.12.0

package/dist/extensions/chat/types.d.ts

@@ -4,7 +4,9 @@
  * Type definitions for the chat widget extension.
  * Core types are re-exported from globals.ts for consistency.
  */
-export type { ChatMessage, ChatChannel, ChatChannelSummary, ChatConfig, ChatTheme, ChatWidgetView, LazyLoadedChatInterface, } from "../../utils/globals";
+export type { ChatMessage, ChatChannel, ChatChannelSummary, ChatConfig, ChatTheme, ChatWidgetView, LazyLoadedChatInterface, SendChatMessageContent, SendChatMessageOptions, } from "../../utils/globals";
+export { messageUsesRichRendering, normalizeSendChatMessageContent, } from "./normalize-send-content";
+export type { NormalizedOutgoingMessage } from "./normalize-send-content";
 /**
  * Sender types for chat messages
  */
@@ -45,75 +47,35 @@ export interface PresenceStatus {
     current_page_url?: string;
 }
 /**
- * Chat event names for analytics tracking
+ * Normalized channel event names for analytics tracking
  *
  * Message events are tracked client-side via capture() for full enrichment
- * (person properties, geo, device, referrer, etc.).
+ * (session, page URL, device, person properties, etc.).
  * Widget UI events (open/close) are exposed via callbacks in ChatConfig.
  *
- * All chat message events use a single event type ($chat_message) with properties:
- * - $sender_type: 'user' | 'ai' | 'agent'
- * - $channel_id: Chat channel ID
- * - $message_id: Message ID
+ * All channel message events use $channel_message with normalized properties:
+ * - $channel_type: channel discriminator ('chat', 'email', 'sms')
+ * - $conversation_id: conversation identifier
+ * - $message_id: message identifier
+ * - $direction: 'inbound' | 'outbound'
+ * - $sender_type: 'user' | 'ai' | 'agent' | 'system'
+ * - $content_preview: first 100 chars of content
  *
  * Tracking is gated by remote config:
  * - chatTracking.trackUserMessages → captures when $sender_type=user
  * - chatTracking.trackAgentMessages → captures when $sender_type=ai|agent
  */
-export declare const CHAT_EVENTS: {
-    /** Tracked client-side for all messages (user, AI, agent) */
-    readonly MESSAGE: "$chat_message";
+export declare const CHANNEL_EVENTS: {
+    readonly MESSAGE: "$channel_message";
 };
-/**
- * Chat event properties for $chat_message (server-side)
- */
-export interface ChatMessageEventProperties {
-    $channel_id: string;
-    $message_id: string;
-    $sender_type: SenderType;
-    $content_preview: string;
-    $ai_mode: boolean;
-    $word_count: number;
-}
-/**
- * @deprecated Use ChatMessageEventProperties instead
- */
-export interface ChatMessageSentEventProperties {
-    $channel_id: string;
+export interface ChannelMessageEventProperties {
+    $channel_type: string;
+    $conversation_id: string;
     $message_id: string;
-    $content_preview: string;
+    $direction: "inbound" | "outbound";
     $sender_type: SenderType;
-    $ai_mode: boolean;
-    $word_count: number;
-}
-/**
- * @deprecated Use ChatMessageEventProperties instead
- */
-export interface ChatMessageReceivedEventProperties {
-    $channel_id: string;
-    $message_id: string;
     $content_preview: string;
-    $sender_type: SenderType;
-    $response_time_ms?: number;
-}
-/**
- * Chat event properties for $chat_started
- */
-export interface ChatStartedEventProperties {
-    $channel_id: string;
-    $initiated_by: "user" | "agent";
-    $ai_mode: boolean;
-}
-/**
- * Chat event properties for $chat_closed
- */
-export interface ChatClosedEventProperties {
-    $channel_id: string;
-    $resolved_by: "agent" | "user" | "system" | "auto";
-    $resolution: "resolved" | "unresolved" | "abandoned";
-    $message_count: number;
-    $duration_seconds: number;
-    $ai_only: boolean;
+    $ai_mode?: boolean;
 }
 /**
  * Internal widget state

package/dist/extensions/chat/widget-registry.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Chat Widget Registry - Extensible widget system for AI-triggered UI.
+ * Tool calls from the AI are mapped to registered widgets; each widget provides render() and onAction().
+ */
+export interface WidgetContext {
+    channelId: string;
+    distinctId: string;
+    primaryColor: string;
+    /** @deprecated Use buildEndpointUrl() instead */
+    apiBase: string;
+    token: string;
+    /** The ID of the message containing this widget */
+    messageId: string;
+    /** Build a full URL for a given endpoint path, respecting api_host */
+    buildEndpointUrl(path: string): string;
+}
+export interface WidgetActionResult {
+    /** Whether the action succeeded — drives metadata-based re-render */
+    success?: boolean;
+    /** @deprecated Use metadata-driven rendering instead. Kept for custom widget compat. */
+    replaceHTML?: string;
+}
+export interface ChatWidgetDefinition {
+    /** Unique type identifier, e.g. "collect_email", "schedule_meeting" */
+    type: string;
+    /** AI tool description (sent to LLM so it knows when to invoke) */
+    toolDescription: string;
+    /** JSON schema shape for the tool parameters */
+    parameters: Record<string, {
+        type: string;
+        description: string;
+    }>;
+    /** Returns an HTML string to render inline in the chat bubble */
+    render(params: Record<string, unknown>, context: WidgetContext): string;
+    /** Called when the widget form is submitted or button clicked */
+    onAction(action: string, data: Record<string, unknown>, context: WidgetContext): Promise<WidgetActionResult>;
+}
+export declare class ChatWidgetRegistry {
+    private _widgets;
+    register(definition: ChatWidgetDefinition): void;
+    get(type: string): ChatWidgetDefinition | undefined;
+    getAll(): ChatWidgetDefinition[];
+    /**
+     * Build tool definitions for the AI from all registered widgets.
+     */
+    getToolDefinitions(): Record<string, {
+        description: string;
+        parameters: Record<string, {
+            type: string;
+            description: string;
+        }>;
+    }>;
+}

package/dist/extensions/chat/widgets/collect-email.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Built-in collect_email widget: renders name + email inputs, POSTs to widget actions API.
+ * UI state is metadata-driven — submitted state is rendered by _renderWidgets().
+ */
+import type { ChatWidgetDefinition } from "../widget-registry";
+export declare const collectEmailWidget: ChatWidgetDefinition;

package/dist/extensions/chat/widgets/escalate-to-human.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Built-in escalate_to_human widget: shows a "Connect with a human" button.
+ * UI state is metadata-driven — submitted state is rendered by _renderWidgets().
+ */
+import type { ChatWidgetDefinition } from "../widget-registry";
+export declare const escalateToHumanWidget: ChatWidgetDefinition;

package/dist/extensions/ga4-proxy.d.ts

@@ -0,0 +1,59 @@
+/**
+ * GA4 Proxy Feature
+ *
+ * Automatically configures gtag.js to send through vTilt's domain.
+ * When enabled, either reconfigures an existing gtag.js or loads a new one
+ * with server_container_url pointing to vTilt's proxy routes.
+ *
+ * Config sources (init config takes priority over remote config):
+ *   vt.init({ ga4: { measurementId: 'G-XXX' } })
+ *   /api/decide → { ga4: { measurementId: 'G-XXX' } }
+ */
+import type { VTiltConfig } from "../types";
+import type { Feature, FeatureConfig } from "../feature";
+export interface GA4ProxyConfig extends FeatureConfig {
+    measurementId?: string;
+    debugMode?: boolean;
+}
+export declare class GA4Proxy implements Feature {
+    readonly name = "GA4Proxy";
+    private _instance;
+    private _config;
+    private _isStarted;
+    private _pendingGtagCallbacks;
+    /** Fires once both client_id and session_id gtag callbacks complete. */
+    onIdentityResolved?: () => void;
+    constructor(instance: {
+        getConfig(): VTiltConfig;
+    }, config?: GA4ProxyConfig);
+    static extractConfig(config: VTiltConfig): GA4ProxyConfig;
+    get isEnabled(): boolean;
+    get isStarted(): boolean;
+    startIfEnabled(): void;
+    stop(): void;
+    /**
+     * Sync user_id to gtag.js so both proxy and MP event streams share
+     * the same identity after identify(). GA4 Realtime uses user_id as
+     * the highest-priority identifier; without this, proxy events (no
+     * user_id) and MP events (with user_id) count as separate users.
+     */
+    setUserId(userId: string | null): void;
+    onConfigUpdate(config: VTiltConfig): void;
+    private _start;
+    private _getApiBase;
+    private _hasGtag;
+    private _reconfigureExistingGtag;
+    private _loadAndConfigureGtag;
+    /**
+     * Use gtag('get', ...) to obtain the authoritative client_id and
+     * session_id from gtag.js. Fires onIdentityResolved once BOTH
+     * callbacks have completed (counter-based).
+     */
+    private _resolveGtagIdentity;
+    /**
+     * Fires after each gtag('get', ...) callback. When all pending callbacks
+     * have settled, notifies the host (EventBuffer) so buffered MP events
+     * can flush with stable GA4 IDs (same client_id as gtag.js).
+     */
+    private _onGtagCallbackSettled;
+}

package/dist/extensions/google-tag-gateway/consent-bridge.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Consent Mode v2 bridge.
+ *
+ * Maps vTilt's 3-boolean consent (analytics / marketing / advertising) to
+ * Google's 4-key Consent Mode v2 payload (ad_storage, ad_user_data,
+ * ad_personalization, analytics_storage) and pushes it through gtag.
+ *
+ * Mapping (default):
+ *   advertising -> ad_storage + ad_user_data + ad_personalization
+ *   analytics   -> analytics_storage
+ *   marketing is not sent to Google by default (it covers email/SMS, not ads).
+ *
+ * Admin UI may override individual keys (`consentOverride`) to hard-wire a
+ * specific value regardless of user consent — useful for jurisdictions or
+ * projects with fixed policies.
+ */
+import type { ConsentState } from "../../core/consent";
+import type { GoogleConsentOverride } from "../../types";
+export type GtagFn = (...args: unknown[]) => void;
+export type GoogleConsentPayload = Record<"ad_storage" | "ad_user_data" | "ad_personalization" | "analytics_storage", "granted" | "denied">;
+export declare function buildConsentPayload(consent: ConsentState, override?: GoogleConsentOverride): GoogleConsentPayload;
+/**
+ * Send the default consent state BEFORE gtag.js loads so that every
+ * subsequent request carries the right flags. Call once at feature start.
+ */
+export declare function pushConsentDefault(gtag: GtagFn, consent: ConsentState, override?: GoogleConsentOverride): void;
+export declare function pushConsentUpdate(gtag: GtagFn, consent: ConsentState, override?: GoogleConsentOverride): void;

package/dist/extensions/google-tag-gateway/enhanced-conversions.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Enhanced Conversions helper.
+ *
+ * Hashes user-provided PII (email/phone/name/address) with SHA-256 before
+ * it leaves the browser, matching Google Ads' Enhanced Conversions format:
+ * https://support.google.com/google-ads/answer/13258081
+ *
+ * Returns an object suitable for `gtag('set', 'user_data', { ... })`.
+ */
+export interface RawUserData {
+    email?: string | null;
+    phone?: string | null;
+    first_name?: string | null;
+    last_name?: string | null;
+    street?: string | null;
+    city?: string | null;
+    region?: string | null;
+    postal_code?: string | null;
+    country?: string | null;
+}
+export interface HashedUserAddress {
+    sha256_first_name?: string;
+    sha256_last_name?: string;
+    sha256_street?: string;
+    city?: string;
+    region?: string;
+    postal_code?: string;
+    country?: string;
+}
+export interface HashedUserData {
+    sha256_email_address?: string;
+    sha256_phone_number?: string;
+    address?: HashedUserAddress;
+}
+export declare function buildHashedUserData(raw: RawUserData): Promise<HashedUserData | null>;

package/dist/extensions/google-tag-gateway/event-bridge.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Automatic event bridge from `vt.capture()` into `gtag('event', ...)`.
+ *
+ * Two layers run in order on every captured event:
+ *
+ * 1. **GA4 forwarder** (`forwardToGtag`) — applies the admin's
+ *    `event_filter`, then an explicit `event_mappings` row, then a built-in
+ *    preset (e.g. `$pageview` → `page_view`), then the `autoForward`
+ *    default-on fallback. Fires `gtag('event', mapped_name, params)` on
+ *    success. This is the primary path: because most customers link GA4 to
+ *    Google Ads, the GA4 event flows to Ads automatically when marked as a
+ *    conversion.
+ * 2. **Ads-only conversions** (`forwardEvent`) — for customers who
+ *    configured direct Ads conversion mappings on the destination. Fires
+ *    `gtag('event', 'conversion', {send_to: 'AW-.../...'})`. Unchanged by
+ *    design so existing deployments keep working.
+ *
+ * Matching on both layers is by exact event name. vTilt's own internal
+ * events (`$identify`, `$set`, etc.) are skipped unless the admin wired
+ * them up explicitly.
+ */
+import type { GoogleAdsConversionMapping, GoogleTagClientConfig } from "../../types";
+import type { GtagFn } from "./consent-bridge";
+export interface ConversionBuildOptions {
+    mapping: GoogleAdsConversionMapping;
+    payload: Record<string, unknown>;
+}
+export interface BuiltConversion {
+    send_to: string;
+    params: Record<string, unknown>;
+}
+export declare function buildConversionParams({ mapping, payload, }: ConversionBuildOptions): BuiltConversion;
+/**
+ * Bridge a single captured event to gtag using the Ads conversion mappings
+ * that match `eventName`. Each matching mapping results in one
+ * `gtag('event', 'conversion', ...)` call.
+ */
+export declare function forwardEvent(gtag: GtagFn, eventName: string, payload: Record<string, unknown>, config: GoogleTagClientConfig): BuiltConversion[];
+/**
+ * Check whether a captured event name is allowed by the admin's
+ * `event_filter`. `exclude` wins over `include`; an empty/missing
+ * `include` means "all events pass". Mirrors the server-side filter
+ * semantics exactly.
+ */
+export declare function isEventAllowed(eventName: string, filter: GoogleTagClientConfig["eventFilter"]): boolean;
+export interface ForwardToGtagResult {
+    /** `true` when a `gtag('event', ...)` call was made. */
+    fired: boolean;
+    /** The event name that was forwarded (post-mapping/preset), if fired. */
+    eventName?: string;
+    /** The params object that was passed to gtag, if fired. */
+    params?: Record<string, unknown>;
+    /** Which rule produced the forward. */
+    source?: "mapping" | "preset" | "auto";
+}
+/**
+ * Forward one captured event to gtag as a GA4 event. Resolution order:
+ *
+ * 1. Filter — `event_filter.exclude` drops, then `event_filter.include`
+ *    (when non-empty) whitelists. Same as the server-side filter.
+ * 2. Explicit mapping — an `event_mappings` row with matching `source`
+ *    wins and always fires, regardless of `autoForward`. This is the
+ *    admin's "force fire" path.
+ * 3. Built-in preset — when no explicit mapping is set and
+ *    `autoForward !== false`, `$pageview`/`$pageleave` fire their GA4
+ *    analogues with sensibly-named params.
+ * 4. Auto-forward fallback — when `autoForward !== false` and the event
+ *    is not a `$*` internal event, fire `gtag('event', eventName, payload)`
+ *    with reserved/internal keys stripped.
+ *
+ * Admins who want a strict allowlist set `autoForward: false` and use
+ * `event_mappings` to enumerate the events they care about.
+ */
+export declare function forwardToGtag(gtag: GtagFn, eventName: string, payload: Record<string, unknown>, config: GoogleTagClientConfig): ForwardToGtagResult;

package/dist/extensions/google-tag-gateway/google-tag-gateway.d.ts

@@ -0,0 +1,95 @@
+/**
+ * GoogleTagGateway feature.
+ *
+ * Orchestrates the client-side half of the Google Tag Gateway destination:
+ *
+ * 1. Maintains `window.dataLayer` / `window.gtag`.
+ * 2. Pushes Consent Mode v2 defaults BEFORE gtag.js loads, and re-pushes
+ *    on `consent:updated` events.
+ * 3. Injects `gtag/js?id=<primary>` from the vTilt gateway (`/gt`) so
+ *    every measurement request flows through the first-party origin.
+ * 4. Subscribes to EVENT_CAPTURED and forwards mapped events to Ads
+ *    (`gtag('event', 'conversion', ...)`).
+ * 5. Exposes a flat `vt.gtag(...)` passthrough for power users.
+ *
+ * Forwards only after `__remote_config_loaded` is true (same signal as
+ * EventBuffer: fresh `/decide` applied, bootstrap, or fetch failure).
+ * Captures before that are queued so we never drop events just because
+ * `/decide` has not committed yet. After remote is ready, we install the
+ * official `dataLayer` + `gtag` shim (`ensureDataLayer`) and forward
+ * immediately — the shim queues until `gtag.js` loads; we do not maintain a
+ * second SDK queue for that window.
+ *
+ * Feature lifecycle matches the rest of the SDK — registered with
+ * FeatureManager via a descriptor that pulls the admin-configured shape
+ * out of `/decide` under the `googleTag` key.
+ */
+import type { VTilt } from "../../vtilt";
+import type { VTiltConfig, GoogleTagClientConfig } from "../../types";
+import type { Feature, FeatureConfig } from "../../feature";
+import { type GtagFn } from "./consent-bridge";
+import { type GtagCall } from "./public-api";
+import { type RawUserData } from "./enhanced-conversions";
+export interface GoogleTagGatewayFeatureConfig extends FeatureConfig {
+    remote?: GoogleTagClientConfig;
+}
+export interface DeliveryLogEntry {
+    ts: number;
+    tag_ids: string[];
+    event_name: string;
+    send_to: string;
+    status: "fired" | "dropped";
+    reason?: string;
+}
+export declare class GoogleTagGateway implements Feature {
+    readonly name = "GoogleTagGateway";
+    private _instance;
+    private _config;
+    private _isStarted;
+    private _scriptInjected;
+    private _scriptLoaded;
+    private _consentDefaultsPushed;
+    private _gtag;
+    private _publicApi;
+    private _loaderOptions;
+    private _unsubscribeCaptured;
+    private _unsubscribeConsent;
+    private _deliveryLog;
+    private readonly _maxDeliveryLog;
+    /**
+     * Captures observed before `__remote_config_loaded` only. Once remote
+     * commits, `ensureDataLayer` + gtag forward — gtag's own queue handles
+     * ordering until `gtag.js` is on the wire.
+     */
+    private readonly _pendingCaptures;
+    constructor(instance: VTilt, config?: GoogleTagGatewayFeatureConfig);
+    static extractConfig(config: VTiltConfig): GoogleTagGatewayFeatureConfig;
+    get isEnabled(): boolean;
+    get isStarted(): boolean;
+    /** Exposed for tests and the public `vt.gtag` binding. */
+    get gtag(): GtagFn;
+    get deliveryLog(): DeliveryLogEntry[];
+    startIfEnabled(): void;
+    stop(): void;
+    onConfigUpdate(config: VTiltConfig): void;
+    /**
+     * Set the user identifiers that power Enhanced Conversions. Values are
+     * normalized + SHA-256 hashed client-side before being pushed to gtag,
+     * so raw PII never leaves the browser.
+     */
+    setUserData(raw: RawUserData): Promise<void>;
+    getRecentPublicCalls(): GtagCall[];
+    private _start;
+    private _drainPending;
+    private _pushConsentDefaultsOnce;
+    private _subscribeCaptured;
+    /**
+     * Handle one captured event. Only `__remote_config_loaded === false` uses
+     * `_pendingCaptures`. After remote commits, we boot the gtag pipeline on
+     * demand (`startIfEnabled`) and forward — the dataLayer shim buffers until
+     * `gtag.js` loads.
+     */
+    private _handleCaptured;
+    private _subscribeConsent;
+    private _record;
+}

package/dist/extensions/google-tag-gateway/gtag-loader.d.ts

@@ -0,0 +1,85 @@
+/**
+ * gtag.js loader.
+ *
+ * Loads `gtag/js?id=<primary>` from the vTilt gateway (`/gt`) so that every
+ * subsequent measurement request — `gtag/js`, `/g/collect`, and
+ * `/pagead/conversion` — stays on the first-party origin. Installs the
+ * standard `window.dataLayer` queue and `window.gtag` shim exactly the way
+ * Google's official snippet does, so any third-party integration that
+ * expects them (Ads editor, Tag Assistant, CMP libraries) keeps working.
+ */
+import type { GoogleTagClientConfig } from "../../types";
+import type { GtagFn } from "./consent-bridge";
+export interface GtagLoaderOptions {
+    /** Origin to load gtag.js from. Must include protocol. */
+    origin: string;
+    /** Path under `origin` that hosts the gateway. Defaults to `/gt`. */
+    gatewayPath: string;
+    /** Primary tag id used in the loader URL (first `G-*`, else first id). */
+    primaryTagId: string;
+    /** All tag ids to `gtag('config', id, ...)` after load. */
+    tagIds: string[];
+    /** Extra per-tag config. Currently only used to set `server_container_url`. */
+    configParams?: Record<string, unknown>;
+    /** Whether gtag.js should send its own `page_view` when configured. */
+    sendPageView?: boolean;
+    /** Enable `debug_mode` on gtag configs. */
+    debugMode?: boolean;
+    /** Enable `conversion_linker` (default true in gtag.js). */
+    conversionLinker?: boolean;
+    /** Domains for the `linker` feature (cross-domain). */
+    linkerDomains?: string[];
+}
+export interface LoadedGtag {
+    gtag: GtagFn;
+    dataLayer: unknown[];
+}
+/**
+ * Ensure a single `window.dataLayer` + `window.gtag` pair exists. Safe to
+ * call multiple times — returns the same references. Matches Google's
+ * reference snippet:
+ *
+ *   window.dataLayer = window.dataLayer || [];
+ *   function gtag(){ dataLayer.push(arguments); }
+ */
+export declare function ensureDataLayer(): LoadedGtag;
+/**
+ * Inject the gtag.js <script> tag pointed at the vTilt gateway. The loader
+ * script is fire-and-forget; the dataLayer/gtag shim queues any calls we
+ * make before the script finishes.
+ */
+export declare function loadGtagScript(options: GtagLoaderOptions, onLoaded?: () => void, onError?: (err: Error) => void): HTMLScriptElement | null;
+/**
+ * Initialize gtag (`'js'` + per-id `'config'`) and — if provided — seed
+ * conversion linker and cross-domain `linker` params. This runs through
+ * the dataLayer shim, so calls made before `gtag.js` finishes loading are
+ * replayed automatically once the script boots.
+ */
+export declare function installGtagConfigs(gtag: GtagFn, options: GtagLoaderOptions): void;
+/**
+ * Derive loader options from the server-provided feature config.
+ *
+ * There are exactly two proxy resolutions:
+ *
+ * | proxyMode  | base                                              | path  |
+ * | ---------- | ------------------------------------------------- | ----- |
+ * | `proxied`  | `api_host` verbatim (or `location.origin`)        | `/gt` |
+ * | `direct`   | `https://www.googletagmanager.com`                | `""`  |
+ *
+ * In proxied mode `api_host` is treated as a verbatim URL prefix — matching
+ * how the rest of the SDK builds URLs (`capture`, array loader, chat). It
+ * may be any of:
+ *
+ *   - a full URL with a path, e.g. `https://proxy.example.com/v1`
+ *   - a bare origin, e.g. `https://proxy.example.com`
+ *   - a relative path, e.g. `/vt` (first-party reverse proxy)
+ *
+ * For `transport_url` we still need an absolute URL, so a relative
+ * `api_host` is expanded against `window.location.origin` in that one
+ * place. The loader `<script>` `src` itself keeps the original relative
+ * form and is resolved by the browser against the document.
+ *
+ * Customers who self-host a proxy simply point `api_host` at it — the
+ * proxy must implement `/gt/*` under that prefix.
+ */
+export declare function buildLoaderOptions(config: GoogleTagClientConfig, apiHost: string | undefined): GtagLoaderOptions | null;

package/dist/extensions/google-tag-gateway/index.d.ts

@@ -0,0 +1,7 @@
+export { GoogleTagGateway, type GoogleTagGatewayFeatureConfig, type DeliveryLogEntry, } from "./google-tag-gateway";
+export { createPublicGtagApi, type PublicGtagApi } from "./public-api";
+export { forwardEvent, buildConversionParams } from "./event-bridge";
+export { ensureDataLayer, loadGtagScript, installGtagConfigs, buildLoaderOptions, type GtagLoaderOptions, } from "./gtag-loader";
+export { pushConsentDefault, pushConsentUpdate, buildConsentPayload, type GtagFn, type GoogleConsentPayload, } from "./consent-bridge";
+export { buildHashedUserData, type HashedUserData, type HashedUserAddress, type RawUserData, } from "./enhanced-conversions";
+export { normalizeEmail, normalizePhone, normalizeBasic, normalizePostalCode, getByPath, coerceNumber, coerceString, } from "./normalize";

package/dist/extensions/google-tag-gateway/normalize.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Google-specific normalization for Enhanced Conversions.
+ *
+ * Follows the rules documented in
+ * https://support.google.com/google-ads/answer/13262500 — phone numbers must be
+ * in E.164 format, emails lowercased with provider-specific dot stripping on
+ * gmail/googlemail, and names/addresses normalized to lowercase without
+ * leading/trailing whitespace.
+ */
+export declare function normalizeEmail(raw: string | null | undefined): string | null;
+/**
+ * Normalize a phone number to E.164. If the input has no leading '+' we
+ * cannot reliably infer the country code, so we return null rather than
+ * send an unhashable/ambiguous value — Enhanced Conversions treats missing
+ * fields as acceptable.
+ */
+export declare function normalizePhone(raw: string | null | undefined): string | null;
+export declare function normalizeBasic(raw: string | null | undefined): string | null;
+/** Postal codes: collapse whitespace, uppercase (some ISO formats are alpha). */
+export declare function normalizePostalCode(raw: string | null | undefined): string | null;
+/**
+ * Read a nested path from an object using dot notation. Used by the
+ * event-bridge to extract `value`/`currency`/`transaction_id` from the
+ * captured event payload based on the admin-configured path.
+ */
+export declare function getByPath(source: unknown, path: string | null | undefined): unknown;
+export declare function coerceNumber(value: unknown): number | undefined;
+export declare function coerceString(value: unknown): string | undefined;

package/dist/extensions/google-tag-gateway/public-api.d.ts

@@ -0,0 +1,23 @@
+/**
+ * `vt.gtag(...)` escape hatch.
+ *
+ * Power users may need to call `gtag` directly (e.g. to fire a custom
+ * conversion from a third-party widget or to set a debug param). We expose
+ * a flat passthrough that:
+ *
+ * - queues calls made before the SDK has booted (keeps them in FIFO order),
+ * - queues calls made before `gtag.js` has loaded (forwarded via the
+ *   `dataLayer` shim, which naturally buffers until the real script runs),
+ * - records every call so tests + the delivery log can see them.
+ */
+import type { GtagFn } from "./consent-bridge";
+export type GtagCall = unknown[];
+export interface PublicGtagApi {
+    /** The flat function exposed as `vt.gtag(...)` */
+    call: GtagFn;
+    /** Flush queued calls to a now-ready gtag implementation. */
+    flush(target: GtagFn): void;
+    /** Observability: recent calls sent through this API (ring buffer). */
+    getRecentCalls(): GtagCall[];
+}
+export declare function createPublicGtagApi(): PublicGtagApi;

package/dist/extensions/history-autocapture.d.ts

@@ -10,8 +10,6 @@ import type { VTilt } from "../vtilt";
 import type { VTiltConfig } from "../types";
 import type { Feature, FeatureConfig } from "../feature";
 export interface HistoryAutocaptureConfig extends FeatureConfig {
-    /** Whether to capture pageviews on history changes */
-    enabled?: boolean;
 }
 /**
  * History Autocapture Feature
@@ -39,6 +37,8 @@ export declare class HistoryAutocapture implements Feature {
     onConfigUpdate(config: VTiltConfig): void;
     private _start;
     private _patchHistoryMethods;
+    /** $pageleave must run while the current URL still reflects the page being left. */
+    private _emitPageleaveIfPathWillChange;
     private _setupPopstateListener;
     private _capturePageview;
 }

package/dist/extensions/replay/index.d.ts

@@ -10,4 +10,4 @@
 export { SessionRecordingWrapper, LAZY_LOADING, type SessionRecordingStatus, type LazyLoadedSessionRecordingInterface, } from "./session-recording-wrapper";
 export { LazyLoadedSessionRecording } from "./session-recording";
 export type { SessionRecordingConfig, SessionStartReason, RecordOptions, RRWebRecord, SnapshotBuffer, CanvasRecordingConfig, NetworkPayloadCaptureConfig, MaskingConfig, TriggerType, } from "./types";
-export { compressEvent, estimateSize, truncateLargeConsoleLogs, splitBuffer, isSessionIdleEvent, isRecordingPausedEvent, isInteractiveEvent, RECORDING_MAX_EVENT_SIZE, RECORDING_BUFFER_TIMEOUT, RECORDING_IDLE_THRESHOLD_MS, } from "./session-recording-utils";
+export { estimateSize, truncateLargeConsoleLogs, splitBuffer, isSessionIdleEvent, isRecordingPausedEvent, isInteractiveEvent, RECORDING_MAX_EVENT_SIZE, RECORDING_BUFFER_TIMEOUT, RECORDING_IDLE_THRESHOLD_MS, } from "./session-recording-utils";