flowgrid-sdk 1.4.1 → 1.5.0

package/dist/lib/flowgrid.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * @fileoverview Unified FlowGrid SDK facade.
  * @module flowgrid
@@ -29,13 +30,135 @@
  * fg.events.client.track({ eventName: "x", sessionId: "...", category: "..." });
  * ```
  */
-import { FlowGridTransport } from "./client/transport";
-import { IdentityManager } from "./utils/identity";
-import { Activation, TrackFeature, TrackPrompt, Experiment } from "./features/core";
-import { PageViews, Sessions, Events, Identify, Funnels, Retention, Attribution, Heatmaps, PerformanceTracking, SessionReplay, } from "./features/analytics";
-import { Products, CartTracking, Checkout, Purchases, Refunds, Promotions, WishlistTracking, CustomerLTV, SearchAnalytics, Subscriptions, } from "./features/ecommerce";
-import { Engagement, Cohorts, ChurnAnalytics, Monetization, MultiPathFunnels, SupportAnalytics, AcquisitionAnalytics, PathAnalytics, AlertsAnalytics, SecurityAnalytics, Forecasting, } from "./features/enterprise";
-import { ActivationTracker, ExperimentTracker, FeatureTracker, PromptTracker, EventTracker, PageViewTracker, SessionTracker, IdentifyTracker, FunnelTracker, RetentionTracker, AttributionTracker, HeatmapTracker, PerformanceTracker, ReplayTracker, ProductTracker, CartTracker, CheckoutTracker, PurchaseTracker, RefundTracker, PromotionTracker, WishlistTracker, SubscriptionTracker, LTVTracker, SearchTracker, EngagementTracker, CohortTracker, ChurnTracker, MonetizationTracker, MultiPathFunnelTracker, SupportTracker, AcquisitionTracker, PathTracker, AlertTracker, SecurityTracker, ForecastingTracker, } from "./tracking";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowGrid = void 0;
+const transport_1 = require("./client/transport");
+const identity_1 = require("./utils/identity");
+const core_1 = require("./features/core");
+const analytics_1 = require("./features/analytics");
+const ecommerce_1 = require("./features/ecommerce");
+// Import directly from sub-barrels (not the top-level ./tracking barrel) so
+// the static module graph never reaches ./tracking/enterprise and its
+// dependencies can be tree-shaken / placed only in the async chunk.
+const core_2 = require("./tracking/core");
+const analytics_2 = require("./tracking/analytics");
+const ecommerce_2 = require("./tracking/ecommerce");
+// ---- Enterprise lazy-load state (module-level singleton) ----
+let _enterpriseFeatures = null;
+let _enterpriseTracking = null;
+function loadEnterpriseModules() {
+    if (_enterpriseFeatures && _enterpriseTracking)
+        return Promise.resolve();
+    return Promise.all([
+        Promise.resolve().then(() => __importStar(require(/* webpackChunkName: "flowgrid-enterprise" */ "./features/enterprise"))),
+        Promise.resolve().then(() => __importStar(require(/* webpackChunkName: "flowgrid-enterprise" */ "./tracking/enterprise"))),
+    ]).then(([features, tracking]) => {
+        _enterpriseFeatures = features;
+        _enterpriseTracking = tracking;
+    });
+}
+const UNHANDLED_TRACK = { handled: false };
+const PRODUCT_KEYS = [
+    "productId",
+    "name",
+    "brand",
+    "category",
+    "variant",
+    "price",
+    "currency",
+    "quantity",
+    "discount",
+    "coupon",
+    "position",
+    "url",
+    "imageUrl",
+    "rating",
+    "reviewCount",
+    "stockStatus",
+    "attributes",
+];
+function handled(value) {
+    return { handled: true, value };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringValue(props, key) {
+    const value = props[key];
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function numberValue(props, key) {
+    const value = props[key];
+    return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function booleanValue(props, key) {
+    const value = props[key];
+    return typeof value === "boolean" ? value : undefined;
+}
+function recordValue(props, key) {
+    const value = props[key];
+    return isRecord(value) ? value : undefined;
+}
+function hasValue(props, key) {
+    const value = props[key];
+    return value !== undefined && value !== null && !(typeof value === "string" && value.length === 0);
+}
+function omitProperties(props, keys) {
+    const next = {};
+    const blocked = new Set([...keys, "domain"]);
+    for (const [key, value] of Object.entries(props)) {
+        if (!blocked.has(key))
+            next[key] = value;
+    }
+    return next;
+}
+function productFrom(props) {
+    const nested = recordValue(props, "product");
+    if (nested)
+        return { ...nested, currency: nested.currency ?? "USD" };
+    if (!hasValue(props, "productId") || !hasValue(props, "name") || !hasValue(props, "price")) {
+        return undefined;
+    }
+    const product = { currency: "USD" };
+    for (const key of PRODUCT_KEYS) {
+        if (props[key] !== undefined)
+            product[key] = props[key];
+    }
+    return product;
+}
 const DEFAULT_ENDPOINT = "https://core.flow-grid.xyz";
 /**
  * Unified FlowGrid SDK client. Instantiate once, use everywhere.
@@ -43,7 +166,7 @@ const DEFAULT_ENDPOINT = "https://core.flow-grid.xyz";
  * Each feature is exposed as a lazily-initialised shortcut wrapper, so the
  * SDK has zero overhead for unused features.
  */
-export class FlowGrid {
+class FlowGrid {
     /**
      * One-line init. Idempotent — calling twice returns the same instance and
      * logs a warning instead of starting auto-instrumentation again.
@@ -78,6 +201,9 @@ export class FlowGrid {
         }
         const fg = new FlowGrid(config.webId, config.endpoint ?? DEFAULT_ENDPOINT, config.apiKey, config.visitorId, config.identityManager, config.transport);
         FlowGrid._instance = fg;
+        // Pre-fetch the enterprise chunk immediately so getters are ready by the
+        // time user code first accesses them (typically well after init returns).
+        void loadEnterpriseModules();
         // Identify the user before auto-instrumentation so the very first events
         // (session_start, page_view) carry the userId.
         if (config.user?.userId) {
@@ -101,6 +227,15 @@ export class FlowGrid {
     static instance() {
         return FlowGrid._instance;
     }
+    /**
+     * Await the enterprise feature chunk. Call this before accessing any
+     * enterprise namespace (`fg.engagement`, `fg.churn`, etc.) if you need
+     * guaranteed availability rather than relying on the background pre-fetch
+     * started by `init()`.
+     */
+    static loadEnterprise() {
+        return loadEnterpriseModules();
+    }
     /**
      * Reset the singleton — primarily for tests / hot-reload. Tears down any
      * active auto-instrumentation.
@@ -127,7 +262,7 @@ export class FlowGrid {
         this.endpoint = endpoint;
         this.apiKey = apiKey;
         this.visitorId = visitorId;
-        this.identityManager = identityManager ?? new IdentityManager(visitorId ? { visitorId } : undefined);
+        this.identityManager = identityManager ?? new identity_1.IdentityManager(visitorId ? { visitorId } : undefined);
         this.config = config;
     }
     raw(key, Klass) {
@@ -147,58 +282,648 @@ export class FlowGrid {
         return instance;
     }
     // ---- Core ----
-    get activation() { return this.wrap("activation", Activation, ActivationTracker); }
-    get features() { return this.wrap("features", TrackFeature, FeatureTracker); }
-    get prompts() { return this.wrap("prompts", TrackPrompt, PromptTracker); }
-    get experiments() { return this.wrap("experiments", Experiment, ExperimentTracker); }
+    get activation() { return this.wrap("activation", core_1.Activation, core_2.ActivationTracker); }
+    get features() { return this.wrap("features", core_1.TrackFeature, core_2.FeatureTracker); }
+    get prompts() { return this.wrap("prompts", core_1.TrackPrompt, core_2.PromptTracker); }
+    get experiments() { return this.wrap("experiments", core_1.Experiment, core_2.ExperimentTracker); }
     // ---- Analytics ----
-    get pageViews() { return this.wrap("pageViews", PageViews, PageViewTracker); }
-    get sessions() { return this.wrap("sessions", Sessions, SessionTracker); }
-    get events() { return this.wrap("events", Events, EventTracker); }
-    get identify() { return this.wrap("identify", Identify, IdentifyTracker); }
-    get funnels() { return this.wrap("funnels", Funnels, FunnelTracker); }
-    get retention() { return this.wrap("retention", Retention, RetentionTracker); }
-    get attribution() { return this.wrap("attribution", Attribution, AttributionTracker); }
-    get heatmaps() { return this.wrap("heatmaps", Heatmaps, HeatmapTracker); }
-    get performance() { return this.wrap("performance", PerformanceTracking, PerformanceTracker); }
-    get replay() { return this.wrap("replay", SessionReplay, ReplayTracker); }
+    get pageViews() { return this.wrap("pageViews", analytics_1.PageViews, analytics_2.PageViewTracker); }
+    get sessions() { return this.wrap("sessions", analytics_1.Sessions, analytics_2.SessionTracker); }
+    get events() { return this.wrap("events", analytics_1.Events, analytics_2.EventTracker); }
+    get identify() { return this.wrap("identify", analytics_1.Identify, analytics_2.IdentifyTracker); }
+    get funnels() { return this.wrap("funnels", analytics_1.Funnels, analytics_2.FunnelTracker); }
+    get retention() { return this.wrap("retention", analytics_1.Retention, analytics_2.RetentionTracker); }
+    get attribution() { return this.wrap("attribution", analytics_1.Attribution, analytics_2.AttributionTracker); }
+    get heatmaps() { return this.wrap("heatmaps", analytics_1.Heatmaps, analytics_2.HeatmapTracker); }
+    get performance() { return this.wrap("performance", analytics_1.PerformanceTracking, analytics_2.PerformanceTracker); }
+    get replay() { return this.wrap("replay", analytics_1.SessionReplay, analytics_2.ReplayTracker); }
     // ---- Ecommerce ----
-    get products() { return this.wrap("products", Products, ProductTracker); }
-    get cart() { return this.wrap("cart", CartTracking, CartTracker); }
-    get checkout() { return this.wrap("checkout", Checkout, CheckoutTracker); }
-    get purchases() { return this.wrap("purchases", Purchases, PurchaseTracker); }
-    get refunds() { return this.wrap("refunds", Refunds, RefundTracker); }
-    get promotions() { return this.wrap("promotions", Promotions, PromotionTracker); }
-    get wishlist() { return this.wrap("wishlist", WishlistTracking, WishlistTracker); }
-    get ltv() { return this.wrap("ltv", CustomerLTV, LTVTracker); }
-    get search() { return this.wrap("search", SearchAnalytics, SearchTracker); }
-    get subscriptions() { return this.wrap("subscriptions", Subscriptions, SubscriptionTracker); }
+    get products() { return this.wrap("products", ecommerce_1.Products, ecommerce_2.ProductTracker); }
+    get cart() { return this.wrap("cart", ecommerce_1.CartTracking, ecommerce_2.CartTracker); }
+    get checkout() { return this.wrap("checkout", ecommerce_1.Checkout, ecommerce_2.CheckoutTracker); }
+    get purchases() { return this.wrap("purchases", ecommerce_1.Purchases, ecommerce_2.PurchaseTracker); }
+    get refunds() { return this.wrap("refunds", ecommerce_1.Refunds, ecommerce_2.RefundTracker); }
+    get promotions() { return this.wrap("promotions", ecommerce_1.Promotions, ecommerce_2.PromotionTracker); }
+    get wishlist() { return this.wrap("wishlist", ecommerce_1.WishlistTracking, ecommerce_2.WishlistTracker); }
+    get ltv() { return this.wrap("ltv", ecommerce_1.CustomerLTV, ecommerce_2.LTVTracker); }
+    get search() { return this.wrap("search", ecommerce_1.SearchAnalytics, ecommerce_2.SearchTracker); }
+    get subscriptions() { return this.wrap("subscriptions", ecommerce_1.Subscriptions, ecommerce_2.SubscriptionTracker); }
     // ---- Enterprise ----
-    get engagement() { return this.wrap("engagement", Engagement, EngagementTracker); }
-    get cohorts() { return this.wrap("cohorts", Cohorts, CohortTracker); }
-    get churn() { return this.wrap("churn", ChurnAnalytics, ChurnTracker); }
-    get monetization() { return this.wrap("monetization", Monetization, MonetizationTracker); }
-    get multiPathFunnels() { return this.wrap("multiPathFunnels", MultiPathFunnels, MultiPathFunnelTracker); }
-    get support() { return this.wrap("support", SupportAnalytics, SupportTracker); }
-    get acquisition() { return this.wrap("acquisition", AcquisitionAnalytics, AcquisitionTracker); }
-    get paths() { return this.wrap("paths", PathAnalytics, PathTracker); }
-    get alerts() { return this.wrap("alerts", AlertsAnalytics, AlertTracker); }
-    get security() { return this.wrap("security", SecurityAnalytics, SecurityTracker); }
-    get forecasting() { return this.wrap("forecasting", Forecasting, ForecastingTracker); }
-    // ==========================================================================
-    // TOP-LEVEL SHORTCUTS — the 80% case
-    // ==========================================================================
-    /**
-     * Track a custom event.
-     *
-     * @example
-     * ```ts
-     * fg.track("signup_completed", { plan: "pro" });
-     * ```
-     */
-    track(eventName, properties, options) {
+    // These getters pull classes from the lazily-loaded enterprise chunk.
+    // The chunk is pre-fetched by init() so it's almost always ready by the
+    // time user code accesses these properties.  loadEnterprise() is available
+    // for the rare case where callers need to await readiness explicitly.
+    _requireEnterprise() {
+        const ent = _enterpriseFeatures;
+        const entT = _enterpriseTracking;
+        if (!ent || !entT) {
+            throw new Error("[FlowGrid] Enterprise features are still loading. " +
+                "await FlowGrid.loadEnterprise() before accessing enterprise namespaces directly.");
+        }
+        return { ent, entT };
+    }
+    get engagement() { const { ent, entT } = this._requireEnterprise(); return this.wrap("engagement", ent.Engagement, entT.EngagementTracker); }
+    get cohorts() { const { ent, entT } = this._requireEnterprise(); return this.wrap("cohorts", ent.Cohorts, entT.CohortTracker); }
+    get churn() { const { ent, entT } = this._requireEnterprise(); return this.wrap("churn", ent.ChurnAnalytics, entT.ChurnTracker); }
+    get monetization() { const { ent, entT } = this._requireEnterprise(); return this.wrap("monetization", ent.Monetization, entT.MonetizationTracker); }
+    get multiPathFunnels() { const { ent, entT } = this._requireEnterprise(); return this.wrap("multiPathFunnels", ent.MultiPathFunnels, entT.MultiPathFunnelTracker); }
+    get support() { const { ent, entT } = this._requireEnterprise(); return this.wrap("support", ent.SupportAnalytics, entT.SupportTracker); }
+    get acquisition() { const { ent, entT } = this._requireEnterprise(); return this.wrap("acquisition", ent.AcquisitionAnalytics, entT.AcquisitionTracker); }
+    get paths() { const { ent, entT } = this._requireEnterprise(); return this.wrap("paths", ent.PathAnalytics, entT.PathTracker); }
+    get alerts() { const { ent, entT } = this._requireEnterprise(); return this.wrap("alerts", ent.AlertsAnalytics, entT.AlertTracker); }
+    get security() { const { ent, entT } = this._requireEnterprise(); return this.wrap("security", ent.SecurityAnalytics, entT.SecurityTracker); }
+    get forecasting() { const { ent, entT } = this._requireEnterprise(); return this.wrap("forecasting", ent.Forecasting, entT.ForecastingTracker); }
+    track(eventName, properties = {}, options = {}) {
+        const contextualProperties = this.withTrackContext(properties, options);
+        const routed = this.dispatchTrack(eventName, contextualProperties, Boolean(options.domain), options.domain);
+        if (routed.handled)
+            return routed.value;
         return this.events.track(eventName, properties, options);
     }
+    withTrackContext(properties, options) {
+        return {
+            ...properties,
+            ...(options.userId !== undefined && properties.userId === undefined ? { userId: options.userId } : {}),
+            ...(options.sessionId !== undefined && properties.sessionId === undefined ? { sessionId: options.sessionId } : {}),
+        };
+    }
+    requireTrackProperties(eventName, properties, keys, strict) {
+        const missing = keys.filter(key => !hasValue(properties, key));
+        if (missing.length === 0)
+            return true;
+        if (strict) {
+            throw new Error(`FlowGrid.track("${eventName}") missing required properties: ${missing.join(", ")}`);
+        }
+        return false;
+    }
+    dispatchTrack(eventName, properties, strict, domain) {
+        const dispatchers = [];
+        if (!domain || domain === "activation")
+            dispatchers.push(() => this.dispatchActivationTrack(eventName, properties, strict));
+        if (!domain || domain === "feature")
+            dispatchers.push(() => this.dispatchFeatureTrack(eventName, properties, strict));
+        if (!domain || domain === "prompt")
+            dispatchers.push(() => this.dispatchPromptTrack(eventName, properties, strict));
+        if (!domain || domain === "experiment")
+            dispatchers.push(() => this.dispatchExperimentTrack(eventName, properties, strict));
+        if (!domain || domain === "analytics" || domain === "funnel" || domain === "retention" || domain === "attribution") {
+            dispatchers.push(() => this.dispatchAnalyticsTrack(eventName, properties, strict, domain));
+        }
+        if (!domain || domain === "ecommerce")
+            dispatchers.push(() => this.dispatchEcommerceTrack(eventName, properties, strict));
+        if (!domain ||
+            domain === "engagement" ||
+            domain === "churn" ||
+            domain === "monetization" ||
+            domain === "support" ||
+            domain === "acquisition" ||
+            domain === "paths" ||
+            domain === "security" ||
+            domain === "multiPathFunnels") {
+            dispatchers.push(() => this.dispatchEnterpriseTrack(eventName, properties, strict, domain));
+        }
+        for (const dispatch of dispatchers) {
+            const result = dispatch();
+            if (result.handled)
+                return result;
+        }
+        return UNHANDLED_TRACK;
+    }
+    dispatchActivationTrack(eventName, properties, strict) {
+        switch (eventName) {
+            case "signup_completed": {
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "method"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.activation.signup(stringValue(properties, "userId"), stringValue(properties, "method"), stringValue(properties, "source"), omitProperties(properties, ["userId", "method", "source"])));
+            }
+            case "onboarding_step": {
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "stepId", "stepName", "stepOrder", "totalSteps"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.activation.onboardingStep(stringValue(properties, "userId"), stringValue(properties, "stepId"), stringValue(properties, "stepName"), numberValue(properties, "stepOrder"), numberValue(properties, "totalSteps"), {
+                    skipped: booleanValue(properties, "skipped"),
+                    timeSpent: numberValue(properties, "timeSpent"),
+                    properties: omitProperties(properties, ["userId", "stepId", "stepName", "stepOrder", "totalSteps", "skipped", "timeSpent"]),
+                }));
+            }
+            case "onboarding_completed": {
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "totalTimeSpent", "stepsCompleted"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.activation.onboardingComplete(stringValue(properties, "userId"), numberValue(properties, "totalTimeSpent"), numberValue(properties, "stepsCompleted"), numberValue(properties, "stepsSkipped") ?? 0));
+            }
+            case "first_action": {
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "actionName", "timeSinceSignup"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.activation.firstAction(stringValue(properties, "userId"), stringValue(properties, "actionName"), numberValue(properties, "timeSinceSignup"), omitProperties(properties, ["userId", "actionName", "timeSinceSignup"])));
+            }
+            default:
+                if (strict)
+                    return handled(this.activation.event(eventName, properties));
+                return UNHANDLED_TRACK;
+        }
+    }
+    dispatchFeatureTrack(eventName, properties, strict) {
+        const actions = {
+            feature_viewed: "viewed",
+            feature_used: "used",
+            feature_completed: "completed",
+            feature_abandoned: "abandoned",
+        };
+        const action = actions[eventName] ?? (eventName === "feature_usage"
+            ? properties.action : undefined);
+        if (eventName === "feature_usage" || action) {
+            if (!this.requireTrackProperties(eventName, properties, ["featureId", "featureName"], strict))
+                return UNHANDLED_TRACK;
+            return handled(this.features.client.trackUsage({
+                ...properties,
+                action: typeof action === "string" ? action : "used",
+            }));
+        }
+        if (strict) {
+            if (!this.requireTrackProperties(eventName, properties, ["userId", "featureName"], true))
+                return UNHANDLED_TRACK;
+            return handled(this.features.create(stringValue(properties, "userId"), eventName, stringValue(properties, "featureName"), omitProperties(properties, ["userId", "featureName"])));
+        }
+        return UNHANDLED_TRACK;
+    }
+    dispatchPromptTrack(eventName, properties, strict) {
+        switch (eventName) {
+            case "prompt_submitted":
+                if (!this.requireTrackProperties(eventName, properties, ["promptId", "promptType"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.prompts.client.trackSubmission(properties));
+            case "prompt_response":
+                if (!this.requireTrackProperties(eventName, properties, ["promptId", "responseTime", "completed"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.prompts.client.trackResponse(properties));
+            case "prompt_feedback":
+                if (!this.requireTrackProperties(eventName, properties, ["promptId", "feedbackType"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.prompts.client.trackFeedback(properties));
+            case "prompt_conversation":
+                if (!this.requireTrackProperties(eventName, properties, ["conversationId", "userId", "turnCount", "totalDuration"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.prompts.conversation(stringValue(properties, "conversationId"), stringValue(properties, "userId"), numberValue(properties, "turnCount"), numberValue(properties, "totalDuration")));
+            default:
+                if (strict || eventName.startsWith("prompt_"))
+                    return handled(this.prompts.event(eventName, properties));
+                return UNHANDLED_TRACK;
+        }
+    }
+    dispatchExperimentTrack(eventName, properties, strict) {
+        switch (eventName) {
+            case "experiment_assignment":
+                if (!this.requireTrackProperties(eventName, properties, ["experimentId", "userId", "variantId"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.experiments.client.assign(properties));
+            case "experiment_exposure":
+                if (!this.requireTrackProperties(eventName, properties, ["experimentId", "userId", "variantId"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.experiments.exposure(stringValue(properties, "experimentId"), stringValue(properties, "userId"), stringValue(properties, "variantId")));
+            case "experiment_conversion":
+                if (!this.requireTrackProperties(eventName, properties, ["experimentId", "userId", "variantId", "metricName"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.experiments.client.trackConversion({
+                    ...properties,
+                    value: numberValue(properties, "value") ?? 1,
+                }));
+            default:
+                if (strict || eventName.startsWith("experiment_")) {
+                    if (!this.requireTrackProperties(eventName, properties, ["variant"], strict))
+                        return UNHANDLED_TRACK;
+                    return handled(this.experiments.client.track({
+                        eventName,
+                        variant: stringValue(properties, "variant"),
+                        properties: omitProperties(properties, ["variant"]),
+                    }));
+                }
+                return UNHANDLED_TRACK;
+        }
+    }
+    dispatchAnalyticsTrack(eventName, properties, strict, domain) {
+        switch (eventName) {
+            case "click_event":
+                if (!this.requireTrackProperties(eventName, properties, ["elementId", "elementText"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.events.client.trackClick(properties));
+            case "form_event":
+                if (!this.requireTrackProperties(eventName, properties, ["formId", "formName"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.events.client.trackForm(properties));
+            case "search_event":
+                if (!this.requireTrackProperties(eventName, properties, ["query", "category"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.events.client.trackSearch(properties));
+            case "error_event":
+                if (!this.requireTrackProperties(eventName, properties, ["message", "type"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.events.client.trackError(properties));
+            case "funnel_step":
+                if (!this.requireTrackProperties(eventName, properties, ["funnelId", "step", "stepNumber"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.funnels.client.trackStep(properties));
+            case "funnel_complete":
+                if (!this.requireTrackProperties(eventName, properties, ["funnelId"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.funnels.complete(stringValue(properties, "funnelId"), stringValue(properties, "userId"), omitProperties(properties, ["funnelId", "userId"])));
+            case "funnel_abandon":
+                if (!this.requireTrackProperties(eventName, properties, ["funnelId", "lastStep"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.funnels.abandon(stringValue(properties, "funnelId"), stringValue(properties, "lastStep"), stringValue(properties, "userId"), stringValue(properties, "reason")));
+            case "user_activity":
+                if (domain && domain !== "retention")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.retention.client.trackActivity(properties));
+            case "attribution_touchpoint":
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "channel"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.attribution.client.trackTouchpoint(properties));
+            case "attribution_conversion":
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "conversionType"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.attribution.client.recordConversion(properties));
+            default:
+                return UNHANDLED_TRACK;
+        }
+    }
+    dispatchEcommerceTrack(eventName, properties, strict) {
+        switch (eventName) {
+            case "product_view": {
+                const product = productFrom(properties);
+                if (!product) {
+                    if (strict)
+                        throw new Error(`FlowGrid.track("${eventName}") missing required properties: product or productId, name, price`);
+                    return UNHANDLED_TRACK;
+                }
+                return handled(this.products.client.view({
+                    ...product,
+                    ...omitProperties(properties, ["product", ...PRODUCT_KEYS]),
+                }));
+            }
+            case "product_impression":
+                if (!this.requireTrackProperties(eventName, properties, ["list"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.products.client.impression(properties));
+            case "product_click": {
+                const product = productFrom(properties);
+                if (!product || !this.requireTrackProperties(eventName, properties, ["listId", "position"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.products.client.click({
+                    ...properties,
+                    product,
+                }));
+            }
+            case "add_to_cart":
+            case "remove_from_cart": {
+                const product = productFrom(properties);
+                if (!product) {
+                    if (strict)
+                        throw new Error(`FlowGrid.track("${eventName}") missing required properties: product or productId, name, price`);
+                    return UNHANDLED_TRACK;
+                }
+                const config = {
+                    ...omitProperties(properties, ["product", ...PRODUCT_KEYS]),
+                    product,
+                    quantity: numberValue(properties, "quantity") ?? 1,
+                };
+                return handled(eventName === "add_to_cart"
+                    ? this.cart.client.addItem(config)
+                    : this.cart.client.removeItem(config));
+            }
+            case "update_cart_item": {
+                const product = productFrom(properties);
+                if (!product || !this.requireTrackProperties(eventName, properties, ["previousQuantity", "newQuantity"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.cart.client.updateItem({
+                    ...omitProperties(properties, ["product", ...PRODUCT_KEYS]),
+                    product,
+                }));
+            }
+            case "view_cart":
+                if (!this.requireTrackProperties(eventName, properties, ["cart"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.cart.client.view(properties));
+            case "begin_checkout":
+                if (!this.requireTrackProperties(eventName, properties, ["cart"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.checkout.client.begin(properties));
+            case "checkout_step":
+                if (!this.requireTrackProperties(eventName, properties, ["step", "stepNumber", "cart"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.checkout.client.step(properties));
+            case "add_shipping_info":
+                if (!this.requireTrackProperties(eventName, properties, ["cart", "shipping"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.checkout.client.addShipping(properties));
+            case "add_payment_info":
+                if (!this.requireTrackProperties(eventName, properties, ["cart", "payment"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.checkout.client.addPayment(properties));
+            case "purchase":
+                if (!this.requireTrackProperties(eventName, properties, ["order"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.purchases.client.track(properties));
+            case "refund":
+                if (!this.requireTrackProperties(eventName, properties, ["orderId", "refundId", "amount", "currency"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.refunds.client.track(properties));
+            case "refund_requested":
+                if (!this.requireTrackProperties(eventName, properties, ["orderId"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.refunds.client.request(stringValue(properties, "orderId"), properties.items, stringValue(properties, "reason")));
+            case "refund_approved":
+                if (!this.requireTrackProperties(eventName, properties, ["refundId", "approvedAmount"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.refunds.client.approve(stringValue(properties, "refundId"), numberValue(properties, "approvedAmount")));
+            case "refund_denied":
+                if (!this.requireTrackProperties(eventName, properties, ["refundId", "reason"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.refunds.client.deny(stringValue(properties, "refundId"), stringValue(properties, "reason")));
+            case "refund_completed":
+                if (!this.requireTrackProperties(eventName, properties, ["refundId", "processedAmount"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.refunds.client.complete(stringValue(properties, "refundId"), numberValue(properties, "processedAmount")));
+            case "promotion_view":
+                if (!this.requireTrackProperties(eventName, properties, ["promotionId", "name", "creative", "position"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.promotions.client.view(properties));
+            case "promotion_click":
+                if (!this.requireTrackProperties(eventName, properties, ["promotionId", "name", "creative", "position"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.promotions.client.click(properties));
+            case "coupon_used":
+                if (!this.requireTrackProperties(eventName, properties, ["code", "orderId", "discountValue", "discountType", "orderValueBefore", "orderValueAfter"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.promotions.client.couponUsed(properties));
+            case "add_to_wishlist":
+            case "remove_from_wishlist": {
+                const product = productFrom(properties);
+                if (!product) {
+                    if (strict)
+                        throw new Error(`FlowGrid.track("${eventName}") missing required properties: product or productId, name, price`);
+                    return UNHANDLED_TRACK;
+                }
+                const config = { ...omitProperties(properties, ["product", ...PRODUCT_KEYS]), product };
+                return handled(eventName === "add_to_wishlist"
+                    ? this.wishlist.client.add(config)
+                    : this.wishlist.client.remove(config));
+            }
+            case "view_wishlist":
+                if (!this.requireTrackProperties(eventName, properties, ["wishlist"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.wishlist.client.view(recordValue(properties, "wishlist")));
+            case "wishlist_to_cart": {
+                const product = productFrom(properties);
+                if (!product) {
+                    if (strict)
+                        throw new Error(`FlowGrid.track("${eventName}") missing required properties: product or productId, name, price`);
+                    return UNHANDLED_TRACK;
+                }
+                return handled(this.wishlist.client.moveToCart(product, stringValue(properties, "wishlistId")));
+            }
+            case "share_wishlist":
+                if (!this.requireTrackProperties(eventName, properties, ["wishlistId", "method"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.wishlist.client.share(stringValue(properties, "wishlistId"), stringValue(properties, "method")));
+            case "subscription_start":
+                if (!this.requireTrackProperties(eventName, properties, ["subscriptionId", "userId", "plan", "mrr", "billingCycle"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.subscriptions.client.start(properties));
+            case "subscription_change":
+                if (!this.requireTrackProperties(eventName, properties, ["subscriptionId", "userId", "previousPlan", "newPlan", "previousMrr", "newMrr", "changeType"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.subscriptions.client.change(properties));
+            case "subscription_cancel":
+                if (!this.requireTrackProperties(eventName, properties, ["subscriptionId", "userId", "plan", "lostMrr"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.subscriptions.client.cancel(properties));
+            case "subscription_renew":
+                if (!this.requireTrackProperties(eventName, properties, ["subscriptionId", "userId", "mrr"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.subscriptions.client.renew(stringValue(properties, "subscriptionId"), stringValue(properties, "userId"), recordValue(properties, "mrr")));
+            case "trial_converted":
+                if (!this.requireTrackProperties(eventName, properties, ["subscriptionId", "userId", "plan", "mrr"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.subscriptions.client.trialConverted(stringValue(properties, "subscriptionId"), stringValue(properties, "userId"), stringValue(properties, "plan"), recordValue(properties, "mrr")));
+            case "trial_expired":
+                if (!this.requireTrackProperties(eventName, properties, ["subscriptionId", "userId"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.subscriptions.client.trialExpired(stringValue(properties, "subscriptionId"), stringValue(properties, "userId")));
+            case "record_acquisition_cost":
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "cost", "channel"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.ltv.client.recordAcquisitionCost(properties));
+            case "update_customer_segment":
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "newSegment"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.ltv.client.updateSegment(stringValue(properties, "userId"), stringValue(properties, "newSegment")));
+            case "site_search":
+                if (!this.requireTrackProperties(eventName, properties, ["query", "resultsCount"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.search.client.track(properties));
+            case "search_result_click": {
+                const product = productFrom(properties);
+                if (!product || !this.requireTrackProperties(eventName, properties, ["query", "position"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.search.client.trackClick({ ...properties, product }));
+            }
+            case "search_refinement":
+                if (!this.requireTrackProperties(eventName, properties, ["originalQuery", "refinedQuery", "refinementType"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.search.client.trackRefinement(stringValue(properties, "originalQuery"), stringValue(properties, "refinedQuery"), stringValue(properties, "refinementType")));
+            case "search_suggestion":
+                if (!this.requireTrackProperties(eventName, properties, ["partialQuery", "selectedSuggestion", "suggestionPosition"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.search.client.trackSuggestion(stringValue(properties, "partialQuery"), stringValue(properties, "selectedSuggestion"), numberValue(properties, "suggestionPosition")));
+            default:
+                return UNHANDLED_TRACK;
+        }
+    }
+    dispatchEnterpriseTrack(eventName, properties, strict, domain) {
+        // Enterprise chunk not yet loaded — let the event fall through to events.track().
+        if (!_enterpriseFeatures || !_enterpriseTracking)
+            return UNHANDLED_TRACK;
+        switch (eventName) {
+            case "engagement.dwell_time":
+            case "engagement_dwell_time":
+                if (domain && domain !== "engagement")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["featureId", "dwellTimeMs"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.engagement.client.trackDwellTime(properties));
+            case "engagement.session_depth":
+            case "engagement_session_depth":
+                if (domain && domain !== "engagement")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["sessionId", "pagesVisited", "featuresUsed", "actionsTaken", "durationMs"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.engagement.client.trackSessionDepth(properties));
+            case "engagement.content_consumption":
+            case "engagement_content_consumption":
+                if (domain && domain !== "engagement")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["contentId", "contentType", "percentageConsumed", "timeSpentMs"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.engagement.client.trackContentConsumption(properties));
+            case "engagement.user_activity":
+            case "engagement_user_activity":
+                if (domain && domain !== "engagement")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "activityType", "durationMs"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.engagement.client.trackUserActivity(properties));
+            case "churn.usage_decay":
+            case "churn_usage_decay":
+                if (domain && domain !== "churn")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "metric", "periods"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.churn.client.trackUsageDecay(properties));
+            case "churn.nps":
+            case "churn_nps":
+                if (domain && domain !== "churn")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "score"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.churn.client.trackNPS(properties));
+            case "churn.churn_event":
+            case "churn_churn_event":
+                if (domain && domain !== "churn")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "churnType"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.churn.client.trackChurn(properties));
+            case "churn.prevention_action":
+            case "churn_prevention_action":
+                if (domain && domain !== "churn")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "actionType"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.churn.client.trackPreventionAction(properties));
+            case "monetization.revenue":
+            case "monetization_revenue":
+                if (domain && domain !== "monetization")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "amount", "currency", "type"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.monetization.client.trackRevenue(properties));
+            case "support.ticket_created":
+            case "support_ticket_created":
+                if (domain && domain !== "support")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["ticketId", "userId", "subject", "category", "priority", "channel"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.support.client.trackTicket(properties));
+            case "support.ticket_updated":
+            case "support_ticket_updated":
+                if (domain && domain !== "support")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["ticketId", "status"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.support.client.updateTicket(properties));
+            case "support.csat":
+            case "support_csat":
+                if (domain && domain !== "support")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["ticketId", "userId", "score"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.support.client.trackCSAT(properties));
+            case "support.feature_complaint":
+            case "support_feature_complaint":
+                if (domain && domain !== "support")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "featureId", "complaintType", "severity"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.support.client.trackFeatureComplaint(properties));
+            case "acquisition.acquired":
+            case "acquisition_acquired":
+                if (domain && domain !== "acquisition")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "source"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.acquisition.client.trackAcquisition(properties));
+            case "acquisition.lifecycle_transition":
+            case "acquisition_lifecycle_transition":
+                if (domain && domain !== "acquisition")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "fromStage", "toStage"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.acquisition.client.trackLifecycleTransition(properties));
+            case "acquisition.campaign_spend":
+            case "acquisition_campaign_spend":
+                if (domain && domain !== "acquisition")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["campaignId", "amount", "date"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.acquisition.client.trackCampaignSpend(properties));
+            case "paths.transition":
+            case "paths_transition":
+                if (domain && domain !== "paths")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "fromScreen", "toScreen"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.paths.client.trackTransition(properties));
+            case "paths.feature_sequence":
+            case "paths_feature_sequence":
+                if (domain && domain !== "paths")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "feature", "order"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.paths.client.trackFeatureSequence(properties));
+            case "security.login_attempt":
+            case "security_login_attempt":
+                if (domain && domain !== "security")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "success"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.security.client.trackLoginAttempt(properties));
+            case "security.role_change":
+            case "security_role_change":
+                if (domain && domain !== "security")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "changedBy", "previousRole", "newRole"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.security.client.trackRoleChange(properties));
+            case "security.permission_change":
+            case "security_permission_change":
+                if (domain && domain !== "security")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "changedBy", "permission", "action"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.security.client.trackPermissionChange(properties));
+            case "security.data_access":
+            case "security_data_access":
+                if (domain && domain !== "security")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "resourceType", "accessType"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.security.client.trackDataAccess(properties));
+            case "security.compliance_event":
+            case "security_compliance_event":
+                if (domain && domain !== "security")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["userId", "eventType"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.security.client.trackComplianceEvent(properties));
+            case "multi_path_funnels.track_step":
+            case "multi_path_funnels_track_step":
+                if (domain && domain !== "multiPathFunnels")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["funnelId", "step", "userId"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.multiPathFunnels.client.trackStep(properties));
+            case "multi_path_funnels.track_micro_conversion":
+            case "multi_path_funnels_track_micro_conversion":
+                if (domain && domain !== "multiPathFunnels")
+                    return UNHANDLED_TRACK;
+                if (!this.requireTrackProperties(eventName, properties, ["conversionId", "userId"], strict))
+                    return UNHANDLED_TRACK;
+                return handled(this.multiPathFunnels.client.trackMicroConversion(properties));
+            default:
+                return UNHANDLED_TRACK;
+        }
+    }
     /**
      * Record an experiment exposure for a user.
      *
@@ -274,7 +999,22 @@ export class FlowGrid {
         }
         if (options.engagement !== false) {
             const engOpts = typeof options.engagement === "object" ? options.engagement : {};
-            teardowns.push(this.engagement.client.autoTrack({ ...engOpts, userId: ctx.userId }));
+            // Engagement lives in the enterprise chunk — start async (mirrors replay pattern).
+            let resolvedEngStop = null;
+            let engStopRequested = false;
+            void loadEnterpriseModules().then(() => {
+                if (engStopRequested)
+                    return;
+                resolvedEngStop = this.engagement.client.autoTrack({ ...engOpts, userId: ctx.userId });
+            });
+            teardowns.push(() => {
+                engStopRequested = true;
+                if (resolvedEngStop)
+                    try {
+                        resolvedEngStop();
+                    }
+                    catch { /* noop */ }
+            });
         }
         if (options.attribution !== false && ctx.userId) {
             this.attribution.captureFromUrl(ctx.userId);
@@ -314,10 +1054,11 @@ export class FlowGrid {
         } };
     }
 }
+exports.FlowGrid = FlowGrid;
 /** Singleton created by {@link FlowGrid.init}. */
 FlowGrid._instance = null;
 // ---- Consent passthrough (static on transport) ----
-FlowGrid.setConsent = FlowGridTransport.setConsent.bind(FlowGridTransport);
-FlowGrid.hasConsent = FlowGridTransport.hasConsent.bind(FlowGridTransport);
-export default FlowGrid;
+FlowGrid.setConsent = transport_1.FlowGridTransport.setConsent.bind(transport_1.FlowGridTransport);
+FlowGrid.hasConsent = transport_1.FlowGridTransport.hasConsent.bind(transport_1.FlowGridTransport);
+exports.default = FlowGrid;
 //# sourceMappingURL=flowgrid.js.map