@qualified-salesforce/web 0.0.1-oidc-bootstrap

package/widget/widget/widget.js

@@ -0,0 +1,1698 @@
+import { __webpack_require__ } from "../../js/runtime.js";
+import { esm_browser_v4, __metadata, _extends, isMobile, __decorate } from "../../js/4101.js";
+import { isDomVisible, DOMReady, addEventListener } from "../../src/dom.js";
+import { registerCustomElement } from "../../src/embedded_forms/QualifiedEmbeddedForm.js";
+import { isDomainMatch, isIframed } from "../../src/iframes.js";
+import { delay as timing_delay } from "../../src/timing.js";
+import { normalizeURL, hasURLMatch } from "../../src/url-utils.js";
+import { default as ApiHandler } from "../api_handler/api_handler.js";
+import { captureWidgetExceptions } from "../capture_widget_exceptions.js";
+import { default as channel } from "../channel.js";
+import { default as Container } from "../container.js";
+import { default as content_activity_emitter } from "../content_activity_emitter.js";
+import { default as DebugModeState, showDebugBanner } from "../debug_mode_state.js";
+import { pageOwnsInlineMeetingBooker } from "../inline_meeting_booker_page.js";
+import { DebugState } from "../local_state/debug_state.js";
+import { TraceState } from "../local_state/trace_state.js";
+import { ButtonsFormsTriggeringTracer } from "../meetings/tracing/buttons_forms_triggering_tracer.js";
+import { AssetsPreloader } from "../multimodal_v2/assets_preloader.js";
+import { default as page_view_activity_emitter } from "../page_view_activity_emitter.js";
+import { default as PersonalizationObserver } from "../personalization_observer.js";
+import { serverLogger } from "../server-logger.js";
+import "../telemetry/index.js";
+import { MessengerUptimeTracker } from "../telemetry/messenger_uptime.js";
+import { default as tracker } from "../tracker.js";
+import { V2Adapter } from "../v2_adapter.js";
+import { default as visitor } from "../visitor.js";
+import { widgetBootstrap } from "../widget_bootstrap.js";
+import { MAP_FORM_FIELD_DENY_LIST } from "../../constants.generated.js";
+import { tryGet } from "../../src/utils.js";
+import { observeBookerOutcome, disposeFormCtaBookerIntent, armFormCtaBookerIntent } from "../form_cta_booker_intent.js";
+import { Sentry, getSentryClient, setSentryContext } from "./sentry.js";
+import { inject, Injectable } from "../../src/mixins/injectable.js";
+import { Disposable } from "../../src/mixins/disposable.js";
+import { default as date_provider } from "../date_provider.js";
+import { default as location_provider } from "../location_provider.js";
+import { CompositeExperienceAdapter } from "../composite_experience_adapter.js";
+import { V1Adapter } from "../v1_adapter.js";
+import { browserIntlSupport, guessTimeZone } from "../../src/timezone.js";
+import "../utils/native_globals.js";
+import { isDefined } from "../../src/type-utils.js";
+import { createBetterPromise } from "../../src/promises.js";
+import { telemetry, withSpan, getTelemetryCtx } from "../telemetry/telemetry.js";
+import { isWidgetBundleResource, widgetConsumer, resolveOriginTime } from "../telemetry/metrics.js";
+
+const cloneDeep = __webpack_require__("39491");
+var cloneDeep_default = /*#__PURE__*/__webpack_require__.n(cloneDeep);
+/* provided dependency */ var __nativeWindowRemoveEventListener = __webpack_require__(68034).kZ;
+/* provided dependency */ var __nativeWindowAddEventListener = __webpack_require__(68034).zh;
+/* provided dependency */ var widget_clearInterval = __webpack_require__(68034).wm;
+/* provided dependency */ var widget_setTimeout = __webpack_require__(68034).pS;
+/* provided dependency */ var widget_setInterval = __webpack_require__(68034).LK;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const LOOPBACK_HOSTS = new Set([
+    "localhost",
+    "127.0.0.1",
+    "::1",
+    "[::1]"
+]);
+const MARKETO_REDIRECT_DEFAULT_TIMEOUT_MS = 500;
+const MARKETO_REDIRECT_MOBILE_TIMEOUT_MS = 1000;
+const MARKETO_LAST_VALID_REBROADCAST_THRESHOLD_MS = 5000;
+const WIDGET_EVENTS = [
+    "apiReady",
+    "sessionCreated",
+    "widgetInitialized"
+];
+function isLoopbackHost(host) {
+    try {
+        return LOOPBACK_HOSTS.has(new URL(host).hostname);
+    } catch (unused) {
+        return host.includes("localhost");
+    }
+}
+class IframedFormExperienceAdapter {
+    dispose() {}
+    showLightboxLoading() {}
+    showMessengerLoading() {}
+    showInlineLoading(_uuid) {}
+    closeLightbox() {}
+    openMessenger() {}
+    setChatIsVisible(_visible) {}
+    addMessengerEventsListener(_handler) {}
+    get apMessagesCount() {
+        return 0;
+    }
+    get autoRespondPounceCount() {
+        return 0;
+    }
+    get visitorResponded() {
+        return false;
+    }
+    get userResponded() {
+        return false;
+    }
+    get originalDocumentTitle() {
+        return null;
+    }
+}
+const ReadyState = {
+    None: 1,
+    Initializing: 2,
+    Ready: 3,
+    Failed: 4
+};
+const ConnectState = {
+    None: 0,
+    Connected: 1,
+    DelayConnect: 2
+};
+const FormStorageKey = "q_form_data";
+class Widget extends Injectable(Disposable(Object)) {
+    static createContainer() {
+        const container = new Container();
+        container.register1("widget", this);
+        container.register1("channel", channel);
+        container.register1("tracker", tracker);
+        container.register1("apiHandler", ApiHandler);
+        container.register1("dateProvider", date_provider);
+        container.register1("locationProvider", location_provider);
+        container.register1("pageViewActivityEmitter", page_view_activity_emitter);
+        container.register1("contentActivityEmitter", content_activity_emitter);
+        container.set("heartbeatManager", {
+            blocked: false
+        });
+        container.register("visitor", visitor);
+        return container;
+    }
+    // Create all the widget objects. Returns the qualified(...) API function.
+    static start(envConfig) {
+        if (envConfig) {
+            this.environmentConfig = envConfig;
+        }
+        const container = this.createContainer();
+        window.__test_container_is_created == null ? void 0 : window.__test_container_is_created.call(window, container);
+        container.resolve("widget", this.environmentConfig);
+        window.__test_widget_is_created == null ? void 0 : window.__test_widget_is_created.call(window, container);
+        return window[window.QualifiedObject];
+    }
+    get visitor() {
+        if (this._visitor) return this._visitor;
+        throw new Error("Visitor not initialized on Widget");
+    }
+    get channel() {
+        if (this._channel) return this._channel;
+        throw new Error("Channel not initialized on Widget");
+    }
+    get tracker() {
+        if (this._tracker) return this._tracker;
+        throw new Error("Tracker not initialized on Widget");
+    }
+    get iframeManager() {
+        if (this._iframeManager) return this._iframeManager;
+        throw new Error("IframeManager not initialized on Widget");
+    }
+    /**
+   * Returns a CompositeExperienceAdapter: the V1Adapter (iframe) paired with a
+   * V2Adapter events bridge, so messenger-event handlers fire whether the iframe
+   * or multimodal owns the session. The bridge is a no-op until
+   * initializeMultimodalV2() binds it. Subclasses (e.g. LinkedWidgetV2) override
+   * this to return a bare V2Adapter. Called once during init().
+   */ createExperienceAdapter() {
+        return new CompositeExperienceAdapter(new V1Adapter(this._iframeManager), new V2Adapter());
+    }
+    /**
+   * Whether this widget should run the full init path (tracker, visitor,
+   * websocket channel) when rendered inside an iframe, rather than taking the
+   * iframed short-circuit in init(). Defaults to false; overridden by widgets
+   * that are themselves full pages a customer may embed (e.g. the meeting booker).
+   */ bootstrapsWhenIframed() {
+        return false;
+    }
+    get offerScript() {
+        return this._offerScript;
+    }
+    get multimodal() {
+        return this._multimodal;
+    }
+    get pageViewActivityEmitter() {
+        if (this._pageViewActivityEmitter) return this._pageViewActivityEmitter;
+        throw new Error("PageViewActivityEmitter not initialized on Widget");
+    }
+    get contentActivityEmitter() {
+        var _this__contentActivityEmitter;
+        return (_this__contentActivityEmitter = this._contentActivityEmitter) != null ? _this__contentActivityEmitter : this._contentActivityEmitter = this.container.resolve("contentActivityEmitter");
+    }
+    resourceUrl() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        return serverLogger.resourceUrl(...args);
+    }
+    async isBlacklisted() {
+        var _this_config_blacklistPaths;
+        if ((_this_config_blacklistPaths = this.config.blacklistPaths) == null ? void 0 : _this_config_blacklistPaths.find((path)=>document.location.pathname.match("^" + path + "$"))) {
+            var _this_config_featureFlags;
+            const uuid = this.container.classFor("visitor").getUuid(this.config.token, (_this_config_featureFlags = this.config.featureFlags) == null ? void 0 : _this_config_featureFlags.websiteVisitorStateV2);
+            if (uuid) {
+                if (await fetch(this.resourceUrl("state/blacklisted", {
+                    uuid
+                })).then((resp)=>resp.json())) {
+                    this.container.resolve("visitor").reset();
+                    return true;
+                }
+            } else {
+                return true;
+            }
+            return false;
+        }
+    }
+    // Checks a URL against the team's allowed domain list if configured.
+    isAllowedOrigin(url) {
+        var _this_config_domains;
+        let rv = false;
+        if (((_this_config_domains = this.config.domains) == null ? void 0 : _this_config_domains.length) === 0) {
+            rv = true;
+        } else if (isDomainMatch(this.config.domains || [], url)) {
+            rv = true;
+        }
+        if (rv) {
+            // here we are console logging isDomainMatch outcome when debug (q_debug url param) is turned on
+            this.debugLog("url " + url + " passed isDomainMatch check using " + this.config.domains);
+        } else {
+            this.debugLog("url " + url + " didn't pass isDomainMatch check using " + this.config.domains);
+        }
+        return rv;
+    }
+    async init(teamToken, config) {
+        if (config === void 0) config = {};
+        var _resolveOriginTime, _this_widgetId;
+        var _window_qualified_docking_setAbortStage, _window_qualified_docking, _window_qualified;
+        (_window_qualified = window.qualified) == null ? void 0 : (_window_qualified_docking = _window_qualified.docking) == null ? void 0 : (_window_qualified_docking_setAbortStage = _window_qualified_docking.setAbortStage) == null ? void 0 : _window_qualified_docking_setAbortStage.call(_window_qualified_docking, "socket_connection");
+        const ctx = getTelemetryCtx();
+        this.isDebug = new URLSearchParams(document.location.search).has("q_debug");
+        this.widgetInitializedAt = performance.now();
+        serverLogger.setConfig(this.config);
+        serverLogger.setWidgetId(this.widgetId || "");
+        if (this.readyState !== ReadyState.None && teamToken !== this.config.token) {
+            // qualified('initialize', ...) called with a different team token. This can happen on
+            // AppExchange as a visitor travels between listings.
+            const newApi = this.onTeardown();
+            newApi("initialize", teamToken, config);
+            return;
+        }
+        // this.loaded check ensures widget is only added to the page once
+        if (this.loaded || !teamToken) {
+            return this.abortInit();
+        }
+        // This needs to be set after the readyState check above, because of the comparison of
+        // `teamToken` with `this.config.token` above.
+        this.config.token = teamToken;
+        // Needs to come after setting the team token
+        const consumer = widgetConsumer();
+        this.widget.logTiming("Time to init widget", "widget_time_to_init_ms", this.widgetInitializedAt, {
+            consumer
+        });
+        // Origin is resolved lazily (not a module-eval snapshot): under npm our code is inlined into
+        // the consumer's content-hashed chunk, so there is no qualified.js resource entry — setup()
+        // records window._q_setupCalledAt and resolveOriginTime falls back to it. null (missing/evicted
+        // resource, or a consumer that never ran setup) becomes NaN so logTiming drops it. Tagged with
+        // the consumer so npm's "time from setup()" isn't mixed with the snippet's "time from page load".
+        this.widget.logTiming("Time to start downloading script", "script_time_to_start_ms", (_resolveOriginTime = resolveOriginTime()) != null ? _resolveOriginTime : NaN, {
+            consumer
+        });
+        // Needs to come after setting the team token. The clients themselves are
+        // created earlier (Sentry.init in the entrypoint); here we just supply the
+        // team-specific proxy URL so subsequent captures are sent. This is a no-op
+        // when the snippet already injected the proxy URL global before the bundle.
+        if (this.config.host && !isLoopbackHost(this.config.host)) {
+            Sentry.setProxyUrl(this.resourceUrl("sentry/proxy"));
+        }
+        // Synchronous initialization code goes here no await should go above this line
+        this.syncInit(config);
+        await telemetry.startActiveSpanAsync("Await DOMReady", {}, ctx, async (span)=>{
+            await DOMReady();
+            span.end();
+        });
+        if (!this.isIframed) this.widget.logTiming("Time to DOMReady", "widget_time_to_domready_ms");
+        // TODO: switch to Mitranim/posterus, thefrontside/effection, or something for structured
+        // concurrency. So that we don't need to litter everything with state checks after every
+        // await.
+        if (this.isDisposed) {
+            return;
+        }
+        // lastClientActivityAt is set on `window` and will be set already if
+        // this is a widget refresh; The conditional prevents clients from coming
+        // out of idle during refresh
+        if (!this.lastClientActivityAt) this.registerClientActivity();
+        // For AppEx and Customer hosted versions of our snippet, we need to grab the
+        // configuration via the web because it is not already compiled into the snippet
+        // like our CDN hosted version.
+        const shouldUseAppExchangeConfig = config.appexchange === true || this.appExchangeEnabled;
+        if (!config.isComplete || shouldUseAppExchangeConfig) {
+            // We're on appexchange, who also passes us `hasCookieConsent` and `appexchangeId` in config.
+            // Or we are on a customer hosted snippet, which does not come with this config built in.
+            const response = await fetch(this.resourceUrl("configuration", shouldUseAppExchangeConfig ? {
+                appexchange: true
+            } : undefined));
+            const teamConfig = await response.json();
+            if (this.isDisposed) {
+                return;
+            }
+            config = _extends({
+                noCookieDomainTest: true
+            }, config, teamConfig);
+        }
+        this.config = _extends({}, this.config, config);
+        this.config.requiresCookieConsent = this.config.hasCookieConsent !== undefined;
+        if (this.isIframed && !this.bootstrapsWhenIframed()) {
+            this.messengerUptime.dispose();
+            const iframeApiHandler = this.apiHandler;
+            const { hasQueuedEarlyIframeLocalApiCalls, markIframeLocalApiReady } = iframeApiHandler;
+            const shouldFlushIframeLocalApis = typeof hasQueuedEarlyIframeLocalApiCalls === "function" && typeof markIframeLocalApiReady === "function" && hasQueuedEarlyIframeLocalApiCalls.call(this.apiHandler);
+            if (shouldFlushIframeLocalApis) {
+                markIframeLocalApiReady.call(this.apiHandler);
+            } else {
+                this.apiHandler.markReady();
+            }
+            const searchParams = new URLSearchParams(document.location.search);
+            if (searchParams.has("q_trace")) {
+                const q_trace_value = searchParams.get("q_trace");
+                this.traceState.setIsTracing(true, q_trace_value);
+            }
+            if (!DebugModeState.isInDebugMode() && this.isDebug) {
+                DebugModeState.initializeDebugMode();
+            }
+            this.readyState = ReadyState.Ready;
+            try {
+                this.cursorPositionProvider = this.container.resolve("cursorPositionProvider");
+            } catch (unused) {
+            // CursorPositionProvider not registered (v2 bundle) — skip.
+            }
+            return;
+        }
+        if (!this.config.requiresCookieConsent && await this.isBlacklisted()) {
+            return this.abortInit();
+        }
+        if (this.isDisposed) {
+            return;
+        }
+        this.timezone = guessTimeZone();
+        this.resetWidgetId();
+        serverLogger.setWidgetId(this.widgetId || "");
+        // The point where this.visitor is initialized is sensitive
+        this._visitor = this.container.resolve("visitor");
+        serverLogger.setVisitorId(this.visitor.uuid);
+        setSentryContext({
+            visitorUuid: this.visitor.uuid,
+            widgetUuid: (_this_widgetId = this.widgetId) != null ? _this_widgetId : undefined
+        });
+        const searchParams = new URLSearchParams(document.location.search);
+        if (searchParams.has("q_trace")) {
+            const q_trace_value = searchParams.get("q_trace");
+            this.traceState.setIsTracing(true, q_trace_value);
+        }
+        if (!DebugModeState.isInDebugMode() && this.isDebug) {
+            DebugModeState.initializeDebugMode();
+        }
+        this.channel.on("refresh", this.onRefresh);
+        this.channel.on("widgetLongTasks", (entries)=>{
+            this.recordWidgetLongTaskSpans("Widget Long Task", JSON.parse(entries));
+        });
+        this.channel.on("startLightboxLoadingSpinner", ()=>{
+            ButtonsFormsTriggeringTracer.finishWaitForLightboxLoadingSpinnerSpan();
+        });
+        this.widget.logTiming("Time to visitor ready", "widget_time_to_visitor_ready_ms");
+        let connectState;
+        await telemetry.startActiveSpanAsync("Connect Cable", {}, ctx, async (span)=>{
+            connectState = await this.connectChannel(false);
+            span.end();
+        });
+        if (this.isDisposed) {
+            return;
+        }
+        if (connectState === ConnectState.DelayConnect) {
+            await telemetry.startActiveSpanAsync("Delay Init", {}, ctx, async (span)=>{
+                await this.delayInit();
+                span.end();
+            });
+        }
+        if (this.isDisposed) {
+            return;
+        }
+        if (connectState !== ConnectState.Connected) {
+            // Try again one more time.
+            await telemetry.startActiveSpanAsync("Connect Cable", {}, ctx, async (span)=>{
+                connectState = await this.connectChannel(false);
+                span.end();
+            });
+        }
+        if (this.isDisposed) {
+            return;
+        }
+        if (connectState !== ConnectState.Connected) {
+            return this.abortInit();
+        }
+        if (this.isDisposed) {
+            return;
+        }
+        this.widget.logTiming("Time to cable connected", "widget_time_to_cable_connected_ms");
+        this.initSpan = telemetry.startSpan("Init Widget", {}, widgetBootstrap.initSpan);
+        await withSpan(ctx, this.initSpan, async ()=>{
+            var _this_config_featureFlags;
+            const ctx = getTelemetryCtx();
+            this._pageViewActivityEmitter = this.container.resolve("pageViewActivityEmitter");
+            this._tracker = this.container.resolve("tracker");
+            try {
+                this._iframeManager = this.container.resolve("iframeManager");
+            } catch (unused) {
+            // IframeManager not registered (v2 bundle) — skip.
+            }
+            this.experienceAdapter = this.createExperienceAdapter();
+            this.apiHandler.markReady();
+            // This is the earliest point we can emit a widget event to the client-side api,
+            // because the apiHandler is marked as ready above
+            this.emitWidgetEvent("apiReady");
+            const item = this.visitor.formExperienceData;
+            if (this.tracker.config.hasSmartForms && item) {
+                const logEventData = {
+                    formType: item.formType,
+                    formId: item.formData.formId,
+                    formActionUrl: item.formData.formActionUrl
+                };
+                const triggers = this.tracker.config.formBotTriggers[item.formType];
+                if (item.formData.formActionUrl && triggers && !triggers.includes(item.formData.formActionUrl.replace(/^https?:\/\//, ""))) {
+                    this.debugState.logEvent("widget:formExperienceDataFound", "error", logEventData, 'Form experience data was found from previous page but "formData.formActionUrl" is not in the list of configured triggers');
+                } else {
+                    var _item_formData_formActionUrl, _this_config_featureFlags1;
+                    this.debugState.logEvent("widget:formExperienceDataFound", "success", logEventData);
+                    this.tracker.setInitializationParams({
+                        smart_form: {
+                            form_type: item.formType,
+                            field_values: {
+                                email: item.formData.formEmail
+                            },
+                            form_data: {
+                                raw: _extends({}, item.formData),
+                                form_id: item.formData.formId,
+                                form_action_url: (_item_formData_formActionUrl = item.formData.formActionUrl) == null ? void 0 : _item_formData_formActionUrl.replace(/^https?:\/\//, ""),
+                                form_email: item.formData.formEmail
+                            }
+                        }
+                    });
+                    ButtonsFormsTriggeringTracer.startSubmitFormSpan({
+                        "form.type": item.formType,
+                        "form.with_redirect": true
+                    });
+                    // Pre-offer SLI: a submit that survived a page redirect, replayed here.
+                    // The clock necessarily starts at the replay, not the original submit —
+                    // the pre-redirect context is gone.
+                    if ((_this_config_featureFlags1 = this.config.featureFlags) == null ? void 0 : _this_config_featureFlags1.bookerJourneySLI) {
+                        // No experience name on this path: `FormExperienceData` carries only
+                        // `formType` plus a `FormDataObject` of `formEmail` / `formId` /
+                        // `formActionUrl`, so there is no `bot_api_name` to read. Left absent
+                        // rather than guessed — the field is optional for exactly this case.
+                        // (`item` comes from untyped visitor state, so the compiler could not
+                        // catch the original wrong read.)
+                        armFormCtaBookerIntent("form:" + item.formType);
+                    }
+                    this.experienceAdapter.showLightboxLoading();
+                    this.visitor.clearFormExperienceData();
+                }
+            }
+            telemetry.startActiveSpanAsync("Init tracker", {}, ctx, async (span)=>{
+                await this.tracker.init();
+                span.end();
+            });
+            try {
+                this.debugState.logEvent("widget:initFormExperience", "success");
+                this.initFormExperience();
+            } catch (error) {
+                // can add the sentry report in the future, but just catch silently now.
+                this.debugState.logEvent("widget:initFormExperience", "error", {
+                    error
+                });
+            }
+            if (this.tracker.config.hasWebsiteEmbeddedForms) {
+                this.initQualifiedForms();
+            }
+            this.exposeDebugging();
+            // TODO: uncomment the below when we remove the Promise Pollyfill
+            //
+            // const iframeSpan = await telemetry.startActiveSpanAsync(
+            //   "Init Iframe",
+            //   null,
+            //   ctx,
+            //   async (span) => {
+            //     await this.iframeManager.init();
+            //     span.end();
+            //
+            //     await this.recordPerformanceEntries(span);
+            //   }
+            // );
+            // TODO: Remove the below block when we remove the Promise Pollyfill
+            const iFrameInitSpan = telemetry.startSpan("Init Iframe", {}, this.initSpan);
+            this.widget.logTiming("Time to pre-multimodal init", "widget_time_to_pre_multimodal_ms");
+            // Start all initializations in parallel
+            const chunkedAssetsStart = performance.now();
+            const timeInit = (init, message, metric)=>Promise.resolve(init).finally(()=>this.widget.logTiming(message, metric, performance.now() - chunkedAssetsStart));
+            const promises = [
+                ...this._iframeManager ? [
+                    timeInit(this._iframeManager.init(), "Iframe init time", "widget_iframe_init_ms")
+                ] : [],
+                timeInit(this.initializeAnalytics(), "Analytics init time", "widget_analytics_init_ms"),
+                timeInit(this.initializeMultimodalV2(), "Multimodal v2 init time", "widget_multimodal_init_ms")
+            ];
+            await Promise.all(promises);
+            iFrameInitSpan.end();
+            this.logTiming("Time to load chunked assets", "widget_chunked_assets_load_ms", performance.now() - chunkedAssetsStart);
+            if (this.isDisposed) {
+                return;
+            }
+            this.channel.startEmitter(); // Start sending channel events to Messenger
+            this.widget.logTiming("Time to channel emitter started", "widget_time_to_emitter_started_ms");
+            await this.recordPerformanceEntries(iFrameInitSpan);
+            this.readyState = ReadyState.Ready;
+            this.emitWidgetEvent("widgetInitialized");
+            // Test dynamic import and code splitting with dummy module
+            if ((_this_config_featureFlags = this.config.featureFlags) == null ? void 0 : _this_config_featureFlags.widgetUseShadowDynamicImport) {
+                await this.initializeDummyModule();
+            }
+            this.trackVisitedContentActivity();
+        });
+    }
+    syncInit(config) {
+        var _config_experimentSelectors;
+        this.loaded = true;
+        this.readyState = ReadyState.Initializing;
+        const normalizedCurrentURL = normalizeURL(window.location.href);
+        const validSelectors = (_config_experimentSelectors = config.experimentSelectors) == null ? void 0 : _config_experimentSelectors.filter((param)=>{
+            let { url } = param;
+            return hasURLMatch(normalizedCurrentURL, normalizeURL(url), url.endsWith("*"));
+        });
+        if (validSelectors && validSelectors.length > 0) {
+            this.personalizationObserver = new PersonalizationObserver(validSelectors);
+            this.personalizationObserver.start();
+        }
+        this._channel = this.container.resolve("channel");
+        this.debugState.channel = this._channel;
+        this.initTelemetry();
+    }
+    debugLog(msg, level, context) {
+        if (level === void 0) level = "info";
+        if (context === void 0) context = {};
+        try {
+            if (this.isDebug) {
+                const prefix = Object.keys(context).length > 0 ? "[" + Object.entries(context).map((param)=>{
+                    let [key, value] = param;
+                    return key + "=" + value;
+                }).join(" ") + "] " : "";
+                switch(level){
+                    case "info":
+                        // eslint-disable-next-line no-console
+                        console.log("" + prefix + msg);
+                        break;
+                    case "error":
+                        // eslint-disable-next-line no-console
+                        console.error("" + prefix + msg);
+                        break;
+                    case "warn":
+                        // eslint-disable-next-line no-console
+                        console.warn("" + prefix + msg);
+                        break;
+                    default:
+                        break;
+                }
+            }
+        } catch (e) {
+            // eslint-disable-next-line no-console
+            console.error(e);
+        }
+    }
+    serverLog() {
+        for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+            args[_key] = arguments[_key];
+        }
+        // Single choke point every surface's SLI passes through, including the legacy
+        // booker's from inside the messenger iframe. Lets the host-side pre-offer
+        // tracker close its window on `booker_shown` without a new bridge event.
+        observeBookerOutcome(args[0]);
+        serverLogger.serverLog(...args);
+    }
+    async delayInit() {
+        this.messengerUptime.dispose();
+        const interacted = new Promise((resolve)=>{
+            const eventHandler = ()=>{
+                __nativeWindowRemoveEventListener("scroll", eventHandler);
+                __nativeWindowRemoveEventListener("mousemove", eventHandler);
+                resolve(true);
+            };
+            __nativeWindowAddEventListener("scroll", eventHandler);
+            __nativeWindowAddEventListener("mousemove", eventHandler);
+        });
+        await timing_delay(10000);
+        await interacted;
+        this.awaitedDelay = true;
+    }
+    async connectChannel(ignoreInvalidUuid) {
+        try {
+            await this.channel.connect();
+        } catch (reason) {
+            switch(reason){
+                case "clear_cookies":
+                    this.visitor.reset();
+                    this.onRefresh();
+                    return ConnectState.None;
+                case "invalid_uuid":
+                    // If this visitor's UUID is not unique, generate a new one and try
+                    // initializing everything again. However, because it's possible
+                    // that bots using a deterministic implementation random() will
+                    // generate non-unique UUIDs, we'll limit to a single retry.
+                    //
+                    // See https://github.com/FatbearLabs/fireball/issues/1809
+                    if (!ignoreInvalidUuid) {
+                        // TODO: move this into init cause it's the one creating the Visitor
+                        this.visitor.reset();
+                    }
+                    return ConnectState.None;
+                case "delay_connect":
+                    var _window_qualified_docking, _window_qualified;
+                    (_window_qualified = window.qualified) == null ? void 0 : (_window_qualified_docking = _window_qualified.docking) == null ? void 0 : _window_qualified_docking.cancelAbort();
+                    return ConnectState.DelayConnect;
+                case "unauthorized":
+                    var _window_qualified_docking1, _window_qualified1;
+                    (_window_qualified1 = window.qualified) == null ? void 0 : (_window_qualified_docking1 = _window_qualified1.docking) == null ? void 0 : _window_qualified_docking1.cancelAbort();
+                    return ConnectState.None;
+                default:
+                    throw reason;
+            }
+        }
+        return ConnectState.Connected;
+    }
+    async initializeAnalytics() {
+        try {
+            if (this.isDisposed) return;
+            this.analytics = await this.loadAnalytics();
+            this.analytics.init();
+        } catch (error) {
+            var _getSentryClient;
+            const message = error instanceof Error ? error.message : String(error);
+            const errorMessage = new Error("Failed to initialize analytics with error: " + message);
+            (_getSentryClient = getSentryClient()) == null ? void 0 : _getSentryClient.captureException(errorMessage);
+        }
+    }
+    async initializeOffers() {
+        try {
+            if (this._offerScript) return;
+            this._offerScript = await this.loadOfferScript();
+        } catch (error) {
+            var _getSentryClient;
+            const message = error instanceof Error ? error.message : String(error);
+            const errorMessage = new Error("Failed to initialize offers with error: " + message);
+            (_getSentryClient = getSentryClient()) == null ? void 0 : _getSentryClient.captureException(errorMessage);
+        }
+    }
+    async initializePageMirror() {
+        try {
+            if (this.pageMirror) return;
+            const pageMirrorFactory = await this.loadPageMirrorFactory();
+            this.pageMirror = pageMirrorFactory.create();
+        } catch (error) {
+            var _getSentryClient;
+            const message = error instanceof Error ? error.message : String(error);
+            const errorMessage = new Error("Failed to initialize page mirror with error: " + message);
+            (_getSentryClient = getSentryClient()) == null ? void 0 : _getSentryClient.captureException(errorMessage);
+        }
+    }
+    async initializeMultimodalV2() {
+        var _window_qualified_docking_setAbortStage, _window_qualified_docking, _window_qualified;
+        (_window_qualified = window.qualified) == null ? void 0 : (_window_qualified_docking = _window_qualified.docking) == null ? void 0 : (_window_qualified_docking_setAbortStage = _window_qualified_docking.setAbortStage) == null ? void 0 : _window_qualified_docking_setAbortStage.call(_window_qualified_docking, "init_multimodal");
+        try {
+            if (this.isDisposed) {
+                this.multimodalReady.resolve(null);
+                return;
+            }
+            AssetsPreloader.preload(this.config);
+            this._multimodal = await this.loadMultimodalV2();
+            // dispose() may have run while the multimodal chunk was loading. Disposal
+            // already ran cleanup() (which tore down the experienceAdapter) and could
+            // not dispose _multimodal, which was unassigned until just now. Calling
+            // init() here would mount a RootStore + shadow host, and bindEventsBridge()
+            // below would re-subscribe the disposed adapter to that new RootStore —
+            // none of which anything would ever clean up. Loading the chunk already
+            // attached the multimodal's construction-time observers, so dispose it
+            // before bailing.
+            if (this.isDisposed) {
+                this._multimodal.tryDispose();
+                this.multimodalReady.resolve(null);
+                return;
+            }
+            this._multimodal.init();
+            this.multimodalReady.resolve(this._multimodal);
+            // Bind the events bridge so multimodal transitions reach messenger-event
+            // handlers. init() creates the RootStore synchronously.
+            this.bindMultimodalEventsBridge();
+        } catch (error) {
+            var _this_config_featureFlags;
+            var _getSentryClient, _this_config_featureFlags1;
+            (_getSentryClient = getSentryClient({
+                project: "multimodal"
+            })) == null ? void 0 : _getSentryClient.captureException(error);
+            if ((_this_config_featureFlags1 = this.config.featureFlags) == null ? void 0 : _this_config_featureFlags1.piperXAgent) {
+                this.serverLog({
+                    message: "multimodal_client_error",
+                    extra: {
+                        method: "inc"
+                    }
+                });
+            }
+            // When the page owns the inline meeting booker, the classic iframe lightbox
+            // was withheld in its favor (see pageOwnsInlineMeetingBooker), so a failed
+            // multimodal_v2 load leaves the visitor with no booking UI at all. Surface
+            // that distinctly so it is alertable rather than lost in generic load
+            // failures.
+            if (pageOwnsInlineMeetingBooker((_this_config_featureFlags = this.config.featureFlags) != null ? _this_config_featureFlags : {})) {
+                var _getSentryClient1;
+                const detail = error instanceof Error ? error.message : String(error);
+                (_getSentryClient1 = getSentryClient({
+                    project: "multimodal"
+                })) == null ? void 0 : _getSentryClient1.captureException(new Error("inline_meeting_booker: multimodal_v2 failed to load; no booking UI rendered (" + detail + ")"));
+            }
+            this.multimodalReady.reject(error);
+        }
+    }
+    async initializeDummyModule() {
+        try {
+            const dummyModule = await this.loadDummyModule();
+            dummyModule.init();
+        } catch (error) {
+            var _getSentryClient;
+            const message = error instanceof Error ? error.message : String(error);
+            const errorMessage = new Error("Failed to initialize dummy module with error: " + message);
+            (_getSentryClient = getSentryClient()) == null ? void 0 : _getSentryClient.captureException(errorMessage);
+        }
+    }
+    // This method is overridden in chunked builds to load the appropriate javascript when needed
+    async loadAnalytics() {
+        return this.container.resolve("analytics");
+    }
+    // This method is overridden in chunked builds to load the appropriate javascript when needed
+    async loadOfferScript() {
+        return this.container.resolve("offerScript");
+    }
+    // This method is overridden in chunked builds to load the appropriate javascript when needed
+    async loadPageMirrorFactory() {
+        return this.container.resolve("pageMirrorFactory");
+    }
+    // This method is overridden in chunked builds to load the appropriate javascript when needed
+    async loadMultimodalV2() {
+        return this.container.resolve("multimodal_v2");
+    }
+    // This method is overridden in chunked builds to load the appropriate javascript when needed
+    async loadDummyModule() {
+        return this.container.load("dummyModule");
+    }
+    // TODO: remove once meeting link has its own pack
+    get isMeetingLink() {
+        return window.location.origin === this.config.meetingLinkHost;
+    }
+    // TODO: remove once meeting link has its own pack
+    get meetingLinkToken() {
+        if (!this.isMeetingLink) return;
+        const pathParts = window.location.pathname.replace(/^\//, "").split("-");
+        return pathParts[pathParts.length - 1];
+    }
+    get connectionParams() {
+        var _navigator;
+        // TODO: get keys from constants in ApplicationCable::Connection
+        const data = {
+            wv: this.config.version || "",
+            token: this.config.token || "",
+            vu: this.visitor.uuid,
+            wu: this.widgetId,
+            ca: this.lastClientActivityAt,
+            tz: this.timezone,
+            bis: browserIntlSupport(),
+            referrer: document.referrer,
+            pv: isDomVisible() ? 1 : 0,
+            fv: this.config.frontendVersion || "",
+            iml: this.isMeetingLink,
+            // TODO: remove once meeting link has its own pack
+            bl: ((_navigator = navigator) == null ? void 0 : _navigator.language) || null
+        };
+        const urlParams = new URLSearchParams(document.location.search);
+        const demoIp = urlParams.get("q_ip");
+        if (demoIp) {
+            data.demo_ip = demoIp;
+        }
+        if (urlParams.get("q_debug_gpt")) {
+            data.debug_gpt = true;
+        }
+        if (this.traceState.isTracing) {
+            data.q_trace = this.traceState.traceValue;
+        }
+        if (this.awaitedDelay) {
+            data.ad = 1;
+        }
+        if (this.appExchangeEnabled) {
+            data.hosted = true;
+            if (this.config.appexchangeId) {
+                data.appxid = this.config.appexchangeId;
+            }
+        }
+        return data;
+    }
+    get appExchangeEnabled() {
+        return this.config.appexchange === true;
+    }
+    exposeDebugging() {
+        // Expose everything for debugging
+        Object.assign(window[window.QualifiedObject] || {}, {
+            widget: this,
+            visitor: this.visitor,
+            tracker: this.tracker,
+            container: this.container
+        });
+    }
+    abortInit() {
+        this.messengerUptime.dispose();
+        this.readyState = ReadyState.Failed;
+    }
+    cleanup() {
+        var _this_experienceAdapter_dispose, _this_experienceAdapter, _this__iframeManager_tryDispose, _this__iframeManager, _this__multimodal_tryDispose, _this__multimodal, _this__tracker_tryDispose, _this__tracker, _this__channel_tryDispose, _this__channel, _this_analytics_tryDispose, _this_analytics, _this__visitor_tryDispose, _this__visitor, _this__offerScript_tryDispose, _this__offerScript, _this__pageViewActivityEmitter_tryDispose, _this__pageViewActivityEmitter, _this_cursorPositionProvider_tryDispose, _this_cursorPositionProvider;
+        this.messengerUptime.dispose();
+        (_this_experienceAdapter = this.experienceAdapter) == null ? void 0 : (_this_experienceAdapter_dispose = _this_experienceAdapter.dispose) == null ? void 0 : _this_experienceAdapter_dispose.call(_this_experienceAdapter);
+        (_this__iframeManager = this._iframeManager) == null ? void 0 : (_this__iframeManager_tryDispose = _this__iframeManager.tryDispose) == null ? void 0 : _this__iframeManager_tryDispose.call(_this__iframeManager);
+        (_this__multimodal = this._multimodal) == null ? void 0 : (_this__multimodal_tryDispose = _this__multimodal.tryDispose) == null ? void 0 : _this__multimodal_tryDispose.call(_this__multimodal);
+        (_this__tracker = this._tracker) == null ? void 0 : (_this__tracker_tryDispose = _this__tracker.tryDispose) == null ? void 0 : _this__tracker_tryDispose.call(_this__tracker);
+        if (this.pageMirror && "tryDispose" in this.pageMirror) {
+            this.pageMirror.tryDispose();
+        }
+        this.apiHandler.tryDispose == null ? void 0 : this.apiHandler.tryDispose.call(this.apiHandler);
+        (_this__channel = this._channel) == null ? void 0 : (_this__channel_tryDispose = _this__channel.tryDispose) == null ? void 0 : _this__channel_tryDispose.call(_this__channel);
+        (_this_analytics = this.analytics) == null ? void 0 : (_this_analytics_tryDispose = _this_analytics.tryDispose) == null ? void 0 : _this_analytics_tryDispose.call(_this_analytics);
+        (_this__visitor = this._visitor) == null ? void 0 : (_this__visitor_tryDispose = _this__visitor.tryDispose) == null ? void 0 : _this__visitor_tryDispose.call(_this__visitor);
+        (_this__offerScript = this._offerScript) == null ? void 0 : (_this__offerScript_tryDispose = _this__offerScript.tryDispose) == null ? void 0 : _this__offerScript_tryDispose.call(_this__offerScript);
+        (_this__pageViewActivityEmitter = this._pageViewActivityEmitter) == null ? void 0 : (_this__pageViewActivityEmitter_tryDispose = _this__pageViewActivityEmitter.tryDispose) == null ? void 0 : _this__pageViewActivityEmitter_tryDispose.call(_this__pageViewActivityEmitter);
+        (_this_cursorPositionProvider = this.cursorPositionProvider) == null ? void 0 : (_this_cursorPositionProvider_tryDispose = _this_cursorPositionProvider.tryDispose) == null ? void 0 : _this_cursorPositionProvider_tryDispose.call(_this_cursorPositionProvider);
+        this.hubspotFormSubmitListenerDisposers.forEach((disposer)=>disposer());
+        this.hubspotFormSubmitListenerDisposers = [];
+        this.hubspotV4PollIds.forEach((id)=>widget_clearInterval(id));
+        this.hubspotV4PollIds = [];
+        this.marketoFormBeforeUnloadDisposer == null ? void 0 : this.marketoFormBeforeUnloadDisposer.call(this);
+        this.marketoFormPageHideDisposer == null ? void 0 : this.marketoFormPageHideDisposer.call(this);
+        this.container.tryDispose();
+        this.loaded = false;
+    }
+    recordInitTelemetry() {
+        var _this_initSpan;
+        (_this_initSpan = this.initSpan) == null ? void 0 : _this_initSpan.end();
+        widgetBootstrap.endBootstrap();
+    }
+    initTelemetry() {
+        if (!this._channel) return;
+        // Arm the messenger uptime SLI for this init attempt; resolveSuccess() fires
+        // on the first initState below.
+        this.messengerUptime.start();
+        // TODO: this section badly needs refactoring
+        let botSelectionSpan;
+        this.channel.once("initTrackerCreatePageView", ()=>botSelectionSpan = telemetry.startSpan("Select Bot", {}, this.initSpan));
+        this.channel.once("initState", ()=>{
+            this.messengerUptime.resolveSuccess();
+            if (botSelectionSpan) {
+                botSelectionSpan.end();
+            }
+            this.recordInitTelemetry();
+        });
+    }
+    initFormExperience() {
+        var _this_config_featureFlags;
+        if (!this.tracker.config.hasSmartForms) {
+            this.debugState.logEvent("widget:hasSmartForms", "error");
+            return;
+        }
+        this.debugState.logEvent("widget:hasSmartForms", "success");
+        if (DebugModeState.isInDebugMode()) {
+            try {
+                showDebugBanner(this.config.host || "");
+            } catch (unused) {
+                // eslint-disable-next-line no-console
+                console.warn("Error showing debug banner!");
+            }
+        }
+        const _this = this;
+        if (typeof window.MktoForms2 !== "undefined") {
+            this.debugState.logEvent("widget:marketo:MktoForms2Found", "success");
+            this.initMarketoForms();
+        } else if (Object.hasOwn(window, "MktoForms2")) {
+        // NO-OP: Property exists - our trap is already set up from previous initialization, prevents "Cannot redefine property" errors.
+        } else {
+            this.debugState.logEvent("widget:marketo:MktoForms2Found", "error");
+            let _MktoForms2;
+            Object.defineProperty(window, "MktoForms2", {
+                get () {
+                    return _MktoForms2;
+                },
+                set (value) {
+                    _MktoForms2 = value;
+                    widget_setTimeout(()=>{
+                        try {
+                            _this.initMarketoForms();
+                        } catch (error) {
+                            _this.debugState.logEvent("widget:marketo:initMarketoFormsComplete", "error", {
+                                error
+                            });
+                        }
+                    }, 0);
+                }
+            });
+        }
+        const windowsToCheck = [
+            window
+        ];
+        if ((_this_config_featureFlags = this.config.featureFlags) == null ? void 0 : _this_config_featureFlags.hubspotIframeFormInitialization) {
+            const iframeElements = Array.from(document.querySelectorAll("iframe"));
+            const iframeWindows = iframeElements.map((iframe)=>tryGet(()=>iframe.contentWindow)).filter(isDefined);
+            windowsToCheck.push(...iframeWindows);
+        }
+        windowsToCheck.forEach((contentWindow)=>{
+            // Iframes with cross-origin domains might throw error
+            try {
+                if (typeof contentWindow.hbspt !== "undefined") {
+                    this.debugState.logEvent("widget:hubspot:hbsptFound", "success");
+                    this.initHubspotForms(contentWindow);
+                } else if (Object.hasOwn(contentWindow, "hbspt")) {
+                // NO-OP: Property exists - our trap is already set up from previous initialization, prevents "Cannot redefine property" errors.
+                } else {
+                    this.debugState.logEvent("widget:hubspot:hbsptFound", "error");
+                    let _hbspt;
+                    Object.defineProperty(contentWindow, "hbspt", {
+                        get () {
+                            return _hbspt;
+                        },
+                        set (value) {
+                            _hbspt = value;
+                            widget_setTimeout(()=>{
+                                try {
+                                    _this.initHubspotForms(contentWindow);
+                                } catch (error) {
+                                    _this.debugState.logEvent("widget:hubspot:initHubspotFormsComplete", "error", {
+                                        error
+                                    });
+                                }
+                            }, 0);
+                        }
+                    });
+                }
+            } catch (error) {
+                this.debugState.logEvent("widget:hubspot:window", "error", {
+                    error
+                });
+            }
+        });
+        // HubSpot V4 Forms API - uses native DOM events
+        // Unlike V3 (hbspt), V4 uses Object.defineProperty internally and checks for
+        // existing properties on window. Using a getter/setter trap prevents HubSpot
+        // from initializing its API, so we poll instead.
+        windowsToCheck.forEach((contentWindow)=>{
+            try {
+                if (typeof contentWindow.HubSpotFormsV4 !== "undefined") {
+                    this.initHubspotFormsV4(contentWindow);
+                } else {
+                    const POLL_INTERVAL_MS = 200;
+                    const MAX_POLL_TIME_MS = 30000;
+                    let elapsed = 0;
+                    const pollId = widget_setInterval(()=>{
+                        elapsed += POLL_INTERVAL_MS;
+                        if (typeof contentWindow.HubSpotFormsV4 !== "undefined") {
+                            widget_clearInterval(pollId);
+                            try {
+                                _this.initHubspotFormsV4(contentWindow);
+                            } catch (error) {
+                                _this.debugState.logEvent("widget:hubspotV4:initComplete", "error", {
+                                    error
+                                });
+                            }
+                        } else if (elapsed >= MAX_POLL_TIME_MS) {
+                            widget_clearInterval(pollId);
+                            _this.debugState.logEvent("widget:hubspotV4:pollTimeout", "error");
+                        }
+                    }, POLL_INTERVAL_MS);
+                    this.hubspotV4PollIds.push(pollId);
+                }
+            } catch (error) {
+                this.debugState.logEvent("widget:hubspotV4:window", "error", {
+                    error
+                });
+            }
+        });
+    }
+    initQualifiedForms() {
+        try {
+            // iframeManager getter throws on v2 (LinkedWidgetV2 doesn't register it).
+            // Forms work without it — only follow-up question sendMessage needs it,
+            // and that's already null-guarded with ?. in QualifiedFormApi (06-01).
+            let iframeManager = null;
+            try {
+                iframeManager = this.iframeManager;
+            } catch (unused) {
+            // v2 path: iframeManager not available, forms work without it
+            }
+            registerCustomElement({
+                channel: this.channel,
+                iframeManager
+            });
+            this.debugState.logEvent("widget:qualifiedForms:initQualifiedForms", "success");
+        } catch (error) {
+            this.debugState.logEvent("widget:qualifiedForms:initQualifiedForms", "error", {
+                error
+            });
+        }
+    }
+    initMarketoForms() {
+        if (typeof window.MktoForms2 === "undefined") {
+            this.debugState.logEvent("widget:marketo:MktoForms2Found", "error", {}, '"window.MktoForms" was previously defined, but is no longer present. This website may have executed javascript which is interfering with the Marketo Smart Form initialization process.');
+            return;
+        }
+        window.MktoForms2.whenReady((mktoForm)=>{
+            if (!this.tracker.config.formBotTriggers.marketo.includes(String(mktoForm.getId()))) return;
+            this.debugState.logEvent("widget:marketo:configuredFormFound", "success", {
+                formId: mktoForm.getId()
+            });
+            mktoForm.onSubmit((form)=>{
+                this.initMarketoFormsRedirectListeners();
+                const values = form.getValues();
+                const formId = values.formid;
+                const formEmail = values.Email;
+                const lengthCheckedValues = this.excludeLongFieldValue(form.getValues(), "marketo");
+                // Store these values temporarily on the instance
+                this.marketoFormSubmitData = lengthCheckedValues;
+                this.debugState.logEvent("widget:marketo:onSubmit", "success", {
+                    formId,
+                    formEmail
+                });
+            });
+            mktoForm.onSuccess((values, followUpUrl)=>{
+                this.marketoFormSucceededAt = Date.now();
+                const formId = values.formid;
+                const formEmail = values.Email;
+                // Use the stored form data from onSubmit
+                if (this.marketoFormSubmitData) {
+                    this.visitor.setFormExperienceDataWithExpiry({
+                        formType: "marketo",
+                        formData: _extends({}, this.marketoFormSubmitData, {
+                            formId,
+                            formEmail
+                        })
+                    });
+                    // Track marketo form fill for offers
+                    this.tracker.pageViewActivityEmitter.emitFormFill({
+                        formType: "marketo"
+                    });
+                }
+                this.debugState.logEvent("widget:marketo:onSuccess", "success", {
+                    formId
+                });
+                widget_setTimeout(()=>{
+                    if (this.marketoFormRedirecting) return;
+                    this.debugState.logEvent("widget:marketo:showExperienceForForm", "success", {
+                        formId
+                    });
+                    this.tracker.showExperienceForForm("marketo", {
+                        raw: _extends({}, values),
+                        formId,
+                        formEmail
+                    });
+                    this.visitor.clearFormExperienceData();
+                    this.visitor.setLastValidRebroadcastTime(this.dateProvider.new().getTime() + this.marketoLastValidRebroadcastThreshold);
+                }, this.marketoRedirectThreshold);
+            });
+            this.debugState.logEvent("widget:marketo:configuredFormSetup", "success", {
+                formId: mktoForm.getId()
+            });
+        });
+        this.debugState.logEvent("widget:marketo:initMarketoFormsComplete", "success");
+    }
+    // A Marketo form's followUpUrl indicates there will be a redirect on success, but
+    // customers often override this behavior using custom JS, causing followUpUrl to
+    // be unreliable. Instead, we rely on event listeners to detect page redirects.
+    // Desktop browsers should fire off both beforeunload and pagehide events, whereas
+    // mobile browsers typically only fire the pagehide event. pagehide is more reliable
+    // than beforeunload (source: https://developer.chrome.com/articles/page-lifecycle-api/)
+    initMarketoFormsRedirectListeners() {
+        // This ensures we don't add multiple listeners in case a visitor submits multiple forms
+        if (!this.marketoFormBeforeUnloadDisposer && !this.marketoFormPageHideDisposer) {
+            this.marketoFormBeforeUnloadDisposer = addEventListener(window, "beforeunload", (e)=>{
+                this.logMarketoRedirectEvent("Preparing to navigate", "desktop", MARKETO_REDIRECT_DEFAULT_TIMEOUT_MS);
+                this.marketoFormRedirecting = true;
+            });
+            this.marketoFormPageHideDisposer = addEventListener(window, "pagehide", (e)=>{
+                this.logMarketoRedirectEvent("Navigated", "mobile", MARKETO_REDIRECT_MOBILE_TIMEOUT_MS);
+                this.marketoFormRedirecting = true;
+            });
+        }
+    }
+    logMarketoRedirectEvent(redirectEventLabel, deviceForLogging, thresholdForLogging) {
+        if (this.marketoFormSucceededAt) {
+            const eventOccurredAt = Date.now() - this.marketoFormSucceededAt;
+            // We use redirectEventLabel to abstract away specific names of page lifecycle events
+            this.debugState.logEvent("widget:marketo:redirectEvent", "success", {
+                redirectEventLabel,
+                eventOccurredAt
+            }, redirectEventLabel + " away from page " + eventOccurredAt + "ms after Marketo form submission");
+            if (eventOccurredAt > thresholdForLogging) {
+                this.debugState.logEvent("widget:marketo:redirectEvent", "error", {
+                    eventOccurredAt,
+                    thresholdForLogging,
+                    deviceForLogging
+                }, eventOccurredAt + "ms exceeds the default threshold of " + thresholdForLogging + "ms we allow for form submission on " + deviceForLogging + ". This may prevent the form experience from firing on " + deviceForLogging);
+            }
+        } else {
+            // Unlikely to occur, logging defensively
+            this.debugState.logEvent("widget:marketo:redirectEvent", "error", {}, "Attempting to redirect before Marketo form successfully submitted");
+        }
+    }
+    initHubspotForms(contentWindow) {
+        if (contentWindow === void 0) contentWindow = window;
+        if (typeof contentWindow.hbspt === "undefined") {
+            this.debugState.logEvent("widget:hubspot:hbsptFound", "error", {}, "window.hbspt was previously defined, but is no longer present. This website may have executed javascript which is interfering with the HubSpot Smart Form initialization process.");
+            return;
+        }
+        let formEmail = null;
+        let values = {};
+        const disposer = addEventListener(contentWindow, "message", (event)=>{
+            var _event_data;
+            if (event.origin !== window.location.origin || ((_event_data = event.data) == null ? void 0 : _event_data.type) !== "hsFormCallback" || !this.tracker.config.formBotTriggers.hubspot.includes(event.data.id)) return;
+            if (event.data.eventName === "onFormSubmit") {
+                const email = event.data.data.filter((field)=>field.name === "email");
+                values = event.data.data.reduce((acc, field)=>{
+                    acc[field.name] = field.value;
+                    return acc;
+                }, {});
+                const lengthCheckedValues = this.excludeLongFieldValue(values, "hubspot");
+                if (email) {
+                    formEmail = email[0].value;
+                    this.visitor.setFormExperienceDataWithExpiry({
+                        formType: "hubspot",
+                        formData: _extends({}, lengthCheckedValues, {
+                            formId: event.data.id,
+                            formEmail
+                        })
+                    });
+                    this.debugState.logEvent("widget:hubspot:onFormSubmit", "success", {
+                        formId: event.data.id,
+                        formEmail
+                    });
+                    // Track hubspot form fill for offers
+                    this.tracker.pageViewActivityEmitter.emitFormFill({
+                        formType: "hubspot"
+                    });
+                }
+            }
+            if (event.data.eventName === "onFormSubmitted") {
+                const followUpUrl = event.data.data.redirectUrl;
+                const formId = event.data.id;
+                const formType = "hubspot";
+                if (!followUpUrl && formEmail) {
+                    this.tracker.showExperienceForForm(formType, {
+                        raw: _extends({}, values),
+                        formId,
+                        formEmail
+                    });
+                    this.visitor.clearFormExperienceData();
+                }
+                this.debugState.logEvent("widget:hubspot:onFormSubmitted", "success", {
+                    formId,
+                    formEmail
+                });
+            }
+        });
+        this.hubspotFormSubmitListenerDisposers.push(disposer);
+        this.debugState.logEvent("widget:hubspot:initHubspotFormsComplete", "success");
+    }
+    // HubSpot V4 Forms API handler - uses native DOM events instead of postMessage
+    initHubspotFormsV4(contentWindow) {
+        if (contentWindow === void 0) contentWindow = window;
+        if (typeof contentWindow.HubSpotFormsV4 === "undefined") {
+            this.debugState.logEvent("widget:hubspotV4:HubSpotFormsV4Found", "error", {}, "window.HubSpotFormsV4 was previously defined, but is no longer present.");
+            return;
+        }
+        this.debugState.logEvent("widget:hubspotV4:HubSpotFormsV4Found", "success");
+        // Track processed submissions to prevent duplicates (in case legacy handler also fires)
+        const processedSubmissions = new Set();
+        const handleSubmissionSuccess = async (event)=>{
+            const customEvent = event;
+            const { formId, instanceId } = customEvent.detail;
+            // Dedupe: create a unique key for this submission
+            const submissionKey = formId + "-" + instanceId;
+            if (processedSubmissions.has(submissionKey)) {
+                return;
+            }
+            // Check if this form is configured in formBotTriggers
+            if (!this.tracker.config.formBotTriggers.hubspot.includes(formId)) {
+                return;
+            }
+            processedSubmissions.add(submissionKey);
+            // Clean up old entries after 5 seconds to allow genuine re-submissions
+            widget_setTimeout(()=>processedSubmissions.delete(submissionKey), 5000);
+            try {
+                const form = contentWindow.HubSpotFormsV4.getFormFromEvent(event);
+                const fieldValues = await form.getFormFieldValues();
+                const redirectUrl = form.getRedirectUrl();
+                // Transform field values to our format (strip HubSpot's "0-1/" prefix from field names)
+                const values = {};
+                let formEmail = null;
+                for (const field of fieldValues){
+                    /**
+           * HubSpot V4 Form Field Prefix Pattern
+           *
+           * HubSpot V4 forms prefix field names with a pattern like "0-1/", "1-2/", etc.
+           * This appears to be an internal HubSpot identifier format: {objectTypeId}-{propertyGroupId}/
+           *
+           * Examples observed:
+           *   - "0-1/email" -> "email"
+           *   - "0-1/firstname" -> "firstname"
+           *   - "1-2/company" -> "company"
+           *
+           * IMPORTANT: This pattern is based on observed behavior from HubSpot's V4 API
+           * (as of January 2026) and is NOT explicitly documented by HubSpot. The format
+           * may change in future HubSpot releases. If form field names stop matching,
+           * check HubSpot's getFormFieldValues() response format for changes.
+           *
+           * @see https://developers.hubspot.com/docs/guides/cms/content/forms/global-form-events
+           */ const fieldName = field.name.replace(/^\d+-\d+\//, "");
+                    const fieldValue = Array.isArray(field.value) ? field.value.join(", ") : field.value;
+                    values[fieldName] = fieldValue;
+                    if (fieldName === "email") {
+                        formEmail = fieldValue;
+                    }
+                }
+                const lengthCheckedValues = this.excludeLongFieldValue(values, "hubspot");
+                if (formEmail) {
+                    if (redirectUrl) {
+                        // Store data for after redirect (will be processed on next page load)
+                        this.visitor.setFormExperienceDataWithExpiry({
+                            formType: "hubspot",
+                            formData: _extends({}, lengthCheckedValues, {
+                                formId,
+                                formEmail
+                            })
+                        });
+                        this.debugState.logEvent("widget:hubspotV4:onSubmissionSuccess", "success", {
+                            formId,
+                            formEmail,
+                            hasRedirect: true
+                        });
+                    } else {
+                        // Show experience immediately (no redirect)
+                        this.tracker.showExperienceForForm("hubspot", {
+                            raw: _extends({}, values),
+                            formId,
+                            formEmail
+                        });
+                        this.visitor.clearFormExperienceData();
+                        this.debugState.logEvent("widget:hubspotV4:onSubmissionSuccess", "success", {
+                            formId,
+                            formEmail,
+                            hasRedirect: false
+                        });
+                    }
+                    // Track form fill for offers
+                    this.tracker.pageViewActivityEmitter.emitFormFill({
+                        formType: "hubspot"
+                    });
+                }
+            } catch (error) {
+                this.debugState.logEvent("widget:hubspotV4:onSubmissionSuccess", "error", {
+                    error
+                });
+            }
+        };
+        const disposer = addEventListener(contentWindow, "hs-form-event:on-submission:success", handleSubmissionSuccess);
+        this.hubspotFormSubmitListenerDisposers.push(disposer);
+        this.debugState.logEvent("widget:hubspotV4:initComplete", "success");
+    }
+    // Browsers typically limit individual cookies to 4096 bytes,
+    // so we check if the whole size of form data exceeds MAP_FORM_DATA_OBJECT_SIZE_LIMIT,
+    // and if it does, delete the values exceeding MAP_FORM_FIELD_SIZE_LIMIT.
+    excludeLongFieldValue(data, formType, formElement) {
+        try {
+            const storedData = {};
+            const exceededLimitKeys = [];
+            let totalSize = 0;
+            switch(formType){
+                case "hubspot":
+                case "marketo":
+                    Object.entries(data).forEach((param)=>{
+                        let [key, value] = param;
+                        if (!MAP_FORM_FIELD_DENY_LIST[formType].includes(key) && typeof value === "string") {
+                            storedData[key] = value;
+                            totalSize += value.length;
+                            if (value.length > (/* inlined export .MAP_FORM_FIELD_SIZE_LIMIT */100)) {
+                                exceededLimitKeys.push(key);
+                            }
+                        }
+                    });
+                    break;
+                case "pardot":
+                    // For pardot, since the name on the input tag is an id and not the field name,
+                    // we need to get the field name from the class of the p or div element instead.
+                    // Besides, we also need to handle all different types of input.
+                    for(let i = 0; formElement && i < formElement.elements.length; i++){
+                        const input = formElement.elements[i];
+                        const outerTag = input.closest("p") || input.closest("div");
+                        if (outerTag && outerTag.className.includes("form-field")) {
+                            // The className for the .form-field p/div tag can either be
+                            // "form-field  first_name pd-text required " (double spaces before field name) or
+                            // "form-field name first_name pd-text required ",
+                            // so we use "const fieldName = field.className.split(" ")[2];" to get the field name.
+                            const fieldName = outerTag.className.split(" ")[2];
+                            if (fieldName && !MAP_FORM_FIELD_DENY_LIST[formType].includes(fieldName)) {
+                                if (input.nodeName === "SELECT") {
+                                    if (data[input.id]) {
+                                        let selectedOptionText;
+                                        const selectInput = input;
+                                        for(let i = 0; i < selectInput.options.length; i++){
+                                            if (selectInput.options[i].value === data[selectInput.id]) {
+                                                selectedOptionText = selectInput.options[i].textContent;
+                                                break;
+                                            }
+                                        }
+                                        storedData[fieldName] = selectedOptionText || "";
+                                    }
+                                } else if (input.type === "checkbox") {
+                                    if (data[input.id]) {
+                                        var _ref;
+                                        var _closestLabel_textContent;
+                                        const closestLabel = outerTag.querySelector('label[for="' + input.id + '"]');
+                                        const fieldValue = (_ref = closestLabel == null ? void 0 : (_closestLabel_textContent = closestLabel.textContent) == null ? void 0 : _closestLabel_textContent.trim()) != null ? _ref : "";
+                                        if (storedData[fieldName]) {
+                                            storedData[fieldName] = storedData[fieldName] + "; " + fieldValue;
+                                        } else {
+                                            storedData[fieldName] = fieldValue;
+                                        }
+                                    }
+                                } else if (input.type === "radio") {
+                                    var _ref1;
+                                    var _closestLabel_textContent1;
+                                    const closestLabel = outerTag.querySelector('label[for="' + input.id + '"]');
+                                    storedData[fieldName] = (_ref1 = closestLabel == null ? void 0 : (_closestLabel_textContent1 = closestLabel.textContent) == null ? void 0 : _closestLabel_textContent1.trim()) != null ? _ref1 : "";
+                                } else {
+                                    storedData[fieldName] = data[input.id];
+                                }
+                                const fieldLength = storedData[fieldName] ? storedData[fieldName].length : 0;
+                                totalSize += fieldLength;
+                                if (fieldLength > (/* inlined export .MAP_FORM_FIELD_SIZE_LIMIT */100)) {
+                                    exceededLimitKeys.push(fieldName);
+                                }
+                            }
+                        }
+                    }
+                    break;
+                default:
+                    this.debugLog("[Qualified] FormType is not one of the MAP forms.");
+            }
+            if (totalSize > (/* inlined export .MAP_FORM_DATA_OBJECT_SIZE_LIMIT */2048)) {
+                exceededLimitKeys.forEach((key)=>{
+                    delete storedData[key];
+                });
+            }
+            return storedData;
+        } catch (e) {
+            this.debugLog("[Qualified] Failed to exclude inputs with long value. Error: " + e);
+            MAP_FORM_FIELD_DENY_LIST[formType].forEach((denyKey)=>{
+                delete data[denyKey];
+            });
+            return data;
+        }
+    }
+    recordPerformanceEntries(iframeSpan) {
+        return new Promise((resolve)=>{
+            // Add snippet download as span
+            // Match by the shared bundle-name predicate rather than hardcoded hosted URLs, so
+            // content-hashed self-hosted zips (qualified-<hash>.js) record their download span too.
+            // npm has no bundle resource (inlined), so this stays empty there — correct.
+            const snippetEntries = performance.getEntries().filter((p)=>p.initiatorType === "script" && isWidgetBundleResource(p.name));
+            this.recordEntriesAsSpans("Download Snippet", snippetEntries, null);
+            this.channel.pingPong("requestAssetPerformanceEntries", "assetPerformanceEntries", {
+                cdnHost: this.config.cdnHost
+            }, (entries)=>{
+                // TODO: ADD Offset from iFrameSpan start
+                this.recordEntriesAsSpans("Download Messenger Asset", JSON.parse(entries), iframeSpan);
+                resolve();
+            });
+        });
+    }
+    recordEntriesAsSpans(name, entries, parentSpan) {
+        if (entries.length === 0) return;
+        entries.forEach((entry)=>{
+            const attributes = {
+                cached: entry.transferSize === 0,
+                url: entry.name
+            };
+            telemetry.recordTimedSpan(name, attributes, parentSpan, entry.startTime, entry.responseEnd);
+        });
+    }
+    recordWidgetLongTaskSpans(name, entries) {
+        if (entries.length === 0) return;
+        entries.forEach((entry)=>{
+            this.channel.perform("record_long_task_spans", {
+                spans: [
+                    {
+                        name,
+                        attributes: {
+                            name: entry.name
+                        },
+                        duration: entry.duration
+                    }
+                ]
+            });
+        });
+    }
+    open() {
+        this.experienceAdapter.openMessenger();
+    }
+    // Hide/show the legacy iframe when the session switches between the legacy and
+    // multimodal messengers (e.g. another tab flips the shared session). No-op on
+    // multimodal-only bundles, which have no iframe.
+    hideLegacyMessenger() {
+        var _this__iframeManager;
+        (_this__iframeManager = this._iframeManager) == null ? void 0 : _this__iframeManager.hideMessenger();
+    }
+    showLegacyMessenger() {
+        var _this__iframeManager;
+        (_this__iframeManager = this._iframeManager) == null ? void 0 : _this__iframeManager.showMessenger();
+    }
+    // Record which presentation layer owns the session so the composite adapter
+    // routes visible-behavior verbs/getters to it. Driven by MultimodalChannel on
+    // every initState. No-op on multimodal-only bundles (bare V2Adapter).
+    setMultimodalOwnsSession(owns) {
+        if (this.experienceAdapter instanceof CompositeExperienceAdapter) {
+            this.experienceAdapter.setMultimodalOwnsSession(owns);
+        }
+    }
+    // (Re)bind the events bridge to the current multimodal RootStore. Called at
+    // initial multimodal init AND again whenever multimodal re-owns the session
+    // after a teardown/rebuild (multi-tab reswitch): teardownUI() disposes the
+    // RootStore and ensureUI() builds a fresh one, so a bridge bound only at init
+    // would keep targeting the disposed store for both events and visible-behavior
+    // verbs/getters. bindRootStore() is idempotent — it tears down the previous
+    // binding first — so repeat calls are safe. No-op on non-composite adapters
+    // (bare V2Adapter v2-only bundles bind their RootStore directly) and before
+    // the RootStore exists.
+    bindMultimodalEventsBridge() {
+        var _this__multimodal;
+        const rootStore = (_this__multimodal = this._multimodal) == null ? void 0 : _this__multimodal.rootStore;
+        if (rootStore && this.experienceAdapter instanceof CompositeExperienceAdapter) {
+            this.experienceAdapter.bindEventsBridge(rootStore);
+        }
+    }
+    endExperience() {
+        this.channel.send({
+            event: "endExperience"
+        });
+    }
+    setCookieConsent(hasCookieConsent) {
+        this.config.hasCookieConsent = hasCookieConsent;
+        this.visitor.updatePersistence(hasCookieConsent);
+    }
+    startShipper() {
+        this.iframeManager.startShipper();
+    }
+    stopShipper() {
+        this.iframeManager.stopShipper();
+    }
+    requestKeyframe() {
+        this.iframeManager.requestKeyframe();
+    }
+    registerClientActivity() {
+        window._q_lastClientActivityAt = this.dateProvider.new().toISOString();
+    }
+    resetWidgetId() {
+        this.widgetId = esm_browser_v4();
+    }
+    getSentryClient() {
+        return getSentryClient();
+    }
+    // Returns a Promise that resolves when the widget is ready.
+    // On v1, this waits for the Postmate iframe handshake (Promise<ParentAPI>).
+    // On v2, LinkedWidgetV2 overrides this to return Promise.resolve() — no iframe handshake needed.
+    // Callers only await this Promise; they never use the resolved value.
+    get initialized() {
+        if (this.isIframed) {
+            return Promise.resolve();
+        }
+        return this.iframeManager.widgetHandshake;
+    }
+    // TODO: Maybe this needs some thought about who should own the cable or should there be a further
+    // abstraction of Network or Messaging, etc.
+    get cable() {
+        return this.channel.cable;
+    }
+    get lastClientActivityAt() {
+        return window._q_lastClientActivityAt;
+    }
+    get loaded() {
+        return window._q_widgetInitialized;
+    }
+    set loaded(value) {
+        window._q_widgetInitialized = value;
+    }
+    get widgetInitializedAt() {
+        return window._q_widgetInitializedAt || 0;
+    }
+    set widgetInitializedAt(value) {
+        window._q_widgetInitializedAt = value;
+    }
+    set widgetIdForInitOffers(value) {
+        window._q_widgetIdForInitOffers = value;
+    }
+    get widgetIdForInitOffers() {
+        return window._q_widgetIdForInitOffers;
+    }
+    // Track content activity whenever we land on a page with a content tracking param
+    trackVisitedContentActivity() {
+        const searchParams = new URLSearchParams(window.location.search);
+        const trackingUuid = searchParams.get("q_ct");
+        if (trackingUuid) {
+            this.contentActivityEmitter.emitActivity({
+                type: "visited",
+                trackingUuid
+            });
+        }
+    }
+    constructor(injectionProps, envConfig){
+        super(injectionProps), this.readyState = ReadyState.None, // `config` is initialized as just the EnvironmentConfig from `Widget.start()`, and then extended
+        // later on by the team-level config in `init`
+        this.config = {}, this.isIframed = false, this.isDebug = false, this.initSpan = null, this.awaitedDelay = false, this.isDisposed = false, this.multimodalReady = createBetterPromise(), // This is a reference to the widget instance itself, for use in captureWidgetExceptions
+        this.widget = this, this.hubspotFormSubmitListenerDisposers = [], this.hubspotV4PollIds = [], this.marketoRedirectThreshold = isMobile().any ? MARKETO_REDIRECT_MOBILE_TIMEOUT_MS : MARKETO_REDIRECT_DEFAULT_TIMEOUT_MS, this.marketoLastValidRebroadcastThreshold = MARKETO_LAST_VALID_REBROADCAST_THRESHOLD_MS, this.marketoFormSucceededAt = null, this.marketoFormRedirecting = false, this.traceState = new TraceState(), this.debugState = new DebugState(), this.messengerUptime = new MessengerUptimeTracker(), this.widgetEventsListeners = [], this.marketoFormSubmitData = null, // Helper function to emit debugLog and serverlog for timing info
+        this.logTiming = (debugMessage, metric, deltaOverride, tags)=>{
+            try {
+                // No NaN and no negative/zero values
+                const validDelta = (num)=>!Number.isNaN(num) && num > 0;
+                let delta;
+                if (deltaOverride === undefined) {
+                    if (!validDelta(this.widget.widgetInitializedAt)) return;
+                    delta = performance.now() - this.widget.widgetInitializedAt;
+                } else {
+                    if (!validDelta(deltaOverride)) return;
+                    delta = deltaOverride;
+                }
+                if (!validDelta(delta)) return;
+                this.widget.debugLog(debugMessage, "info", {
+                    durationMs: delta
+                });
+                this.widget.serverLog({
+                    message: metric,
+                    type: "log",
+                    extra: _extends({
+                        method: "dist",
+                        operand: delta
+                    }, tags ? {
+                        tags
+                    } : {})
+                });
+            } catch (e) {
+                // Wrap in a try/catch to prevent error-handling code from causing regressions
+                console.warn("Qualified: An unexpected issue occurred in logTiming", e); // eslint-disable-line no-console
+            }
+        }, this.addWidgetEventsListener = (handler)=>{
+            try {
+                this.widgetEventsListeners.push(handler);
+            } catch (e) {
+                console.error("Qualified: Error in Widget#addWidgetEventsListener", e); // eslint-disable-line no-console
+            }
+        }, this.emitWidgetEvent = (eventName)=>{
+            if (this.config.clientApiHandleWidgetEventsEnabled && WIDGET_EVENTS.includes(eventName)) {
+                this.widgetEventsListeners.forEach((eventListener)=>{
+                    try {
+                        eventListener(eventName);
+                    } catch (e) {
+                        console.error("Qualified: Error when calling eventListener in Widget#emitWidgetEvent", e); // eslint-disable-line no-console
+                    }
+                });
+            }
+        }, // When qualified('teardown') is used. Kills off all objects and re-creates them unintialized.
+        this.onTeardown = ()=>{
+            this.dispose();
+            return this.constructor.start();
+        }, // When backend sends a force refresh message
+        this.onRefresh = ()=>{
+            this.dispose();
+            // npm/bundled consumers own the bundle: our code is inlined into their content-hashed chunk,
+            // so there is no `qualified.js` script tag to remove and re-download. Re-fetching a script is
+            // meaningless here (and previously no-oped silently). Surface it and stop — re-initialisation is
+            // the consumer's call via setup(); this ticket does not add an npm refresh path.
+            if (widgetConsumer() === "npm") {
+                this.debugLog("[Qualified] Force refresh skipped: bundled (npm) consumer owns the widget bundle; " + "no hosted script to reload.");
+                return;
+            }
+            widget_setTimeout(()=>{
+                const oldScript = document.querySelector('script[src*="qualified.js"]');
+                if (oldScript) {
+                    oldScript.parentNode.removeChild(oldScript);
+                    const newScript = document.createElement("script");
+                    newScript.src = oldScript.src + "&" + new Date().getTime();
+                    document.head.appendChild(newScript);
+                } else {
+                    this.debugLog("[Qualified] Force refresh: no hosted qualified.js script tag found; skipping reload.");
+                }
+            }, Math.floor(Math.random() * 3000) // Delay up to 3s to give backend some breathing room.
+            );
+        };
+        // Ensures that widget is added to the page only once
+        if (this.loaded) {
+            // eslint-disable-next-line no-console
+            console.warn("Qualified widget already initialized. Aborting.");
+            return;
+        }
+        this.config = cloneDeep_default()(envConfig);
+        this.isIframed = isIframed();
+        // The form/CTA pre-offer tracker is a module singleton, so nothing else
+        // unhooks it — unlike the multimodal one, which `RootStore#dispose` owns.
+        // Registered here rather than in `onTeardown` so every disposal path is
+        // covered: `onRefresh` disposes too, and both then restart the widget.
+        this.callOnDispose(disposeFormCtaBookerIntent);
+        this.apiHandler.init();
+    }
+}
+// TODO: rename to Supervisor, cause this is now widget/widget/widget.js
+
+__decorate([
+    captureWidgetExceptions,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [
+        typeof EnvironmentConfig === "undefined" ? Object : EnvironmentConfig
+    ]),
+    __metadata("design:returntype", void 0)
+], Widget, "start", null);
+__decorate([
+    inject,
+    __metadata("design:type", typeof BaseApiHandler === "undefined" ? Object : BaseApiHandler)
+], Widget.prototype, "apiHandler", void 0);
+__decorate([
+    inject,
+    __metadata("design:type", typeof date_provider === "undefined" ? Object : date_provider)
+], Widget.prototype, "dateProvider", void 0);
+__decorate([
+    captureWidgetExceptions,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [
+        String,
+        typeof TeamConfig === "undefined" ? Object : TeamConfig
+    ]),
+    __metadata("design:returntype", Promise)
+], Widget.prototype, "init", null);
+__decorate([
+    captureWidgetExceptions(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", void 0)
+], Widget.prototype, "trackVisitedContentActivity", null);
+
+var widget_FormStorageKey = /* unused export */ undefined;
+export { widget_FormStorageKey as FormStorageKey };
+export default Widget;