@thoughtspot/visual-embed-sdk 1.52.1 → 1.52.2-beta.0

package/dist/tsembed.es.js

@@ -1,4 +1,4 @@
-/* @thoughtspot/visual-embed-sdk version 1.52.1 */
+/* @thoughtspot/visual-embed-sdk version 1.52.2-beta.0 */
 'use client';
 function _mergeNamespaces(n, m) {
     m.forEach(function (e) {
@@ -3766,6 +3766,12 @@ var HostEvent;
      * ```js
      * const data = await liveboardEmbed.trigger(HostEvent.GetFilters);
      *     console.log('data', data);
+     * // {
+     * //   liveboardFilters: [ ... ],
+     * //   runtimeFilters: [
+     * //     { columnName: "Region", operator: "IN", values: ["West"] }
+     * //   ]
+     * // }
      * ```
      * @example
      * ```js
@@ -3790,9 +3796,9 @@ var HostEvent;
      *
      * Each filter object must include the following attributes:
      *
-     * `column` - Name of the column to filter on.
+     * `columnName` - Name of the column to filter on.
      *
-     * `oper`  - Filter operator, for example, EQ, IN, CONTAINS.
+     * `operator`  - Filter operator, for example, EQ, IN, CONTAINS.
      *  For information about the supported filter operators,
      *  see link:https://developers.thoughtspot.com/docs/runtime-filters#rtOperator[Developer Documentation].
      *
@@ -3819,8 +3825,8 @@ var HostEvent;
      *
      * liveboardEmbed.trigger(HostEvent.UpdateFilters, {
      *     filter: {
-     *         column: "item type",
-     *         oper: "IN",
+     *         columnName: "item type",
+     *         operator: "IN",
      *         values: ["bags","shirts"]
      *        }
      *    });
@@ -3830,8 +3836,8 @@ var HostEvent;
      *
      * liveboardEmbed.trigger(HostEvent.UpdateFilters, {
      *     filter: {
-     *         column: "date",
-     *         oper: "EQ",
+     *         columnName: "date",
+     *         operator: "EQ",
      *         values: ["JULY","2023"],
      *         type: "MONTH_YEAR"
      *        }
@@ -3842,18 +3848,18 @@ var HostEvent;
      * ```js
      * liveboardEmbed.trigger(HostEvent.UpdateFilters, {
      *  filters: [{
-     *      column: "Item Type",
-     *      oper: 'IN',
+     *      columnName: "Item Type",
+     *      operator: 'IN',
      *      values: ["bags","shirts"]
      *  },
      *    {
-     *      column: "Region",
-     *      oper: 'IN',
+     *      columnName: "Region",
+     *      operator: 'IN',
      *      values: ["West","Midwest"]
      *  },
      *    {
-     *      column: "Date",
-     *      oper: 'EQ',
+     *      columnName: "Date",
+     *      operator: 'EQ',
      *      values: ["2023-07-31"],
      *      type: "EXACT_DATE"
      *    }]
@@ -3867,13 +3873,13 @@ var HostEvent;
      * ```js
      * liveboardEmbed.trigger(HostEvent.UpdateFilters, {
      *  filters: [{
-     *      column: "(Sample) Retail - Apparel::city",
-     *      oper: 'IN',
+     *      columnName: "(Sample) Retail - Apparel::city",
+     *      operator: 'IN',
      *      values: ["atlanta"]
      *  },
      *  {
-     *      column: "(Sample) Retail - Apparel::Region",
-     *      oper: 'IN',
+     *      columnName: "(Sample) Retail - Apparel::Region",
+     *      operator: 'IN',
      *      values: ["West","Midwest"]
      *  }]
      * });
@@ -3884,8 +3890,8 @@ var HostEvent;
      * import { ContextType } from '@thoughtspot/visual-embed-sdk';
      * liveboardEmbed.trigger(HostEvent.UpdateFilters, {
      *     filter: {
-     *         column: "item type",
-     *         oper: "IN",
+     *         columnName: "item type",
+     *         operator: "IN",
      *         values: ["shoes", "boots"]
      *     }
      * }, ContextType.Liveboard);
@@ -3895,8 +3901,8 @@ var HostEvent;
      * // Scope the filter to a specific Liveboard tab
      * liveboardEmbed.trigger(HostEvent.UpdateFilters, {
      *     filter: {
-     *         column: "item type",
-     *         oper: "IN",
+     *         columnName: "item type",
+     *         operator: "IN",
      *         values: ["bags", "shirts"],
      *         applicability: {
      *             level: "TAB",
@@ -3905,6 +3911,12 @@ var HostEvent;
      *     }
      * });
      * ```
+     * Use `columnName` and `operator` - the same spelling as
+     * {@link RuntimeFilter}. The older `column` and `oper` spellings are
+     * deprecated; they are still accepted, but pass only one spelling of each
+     * field, never both. To reapply the filter state captured from
+     * {@link EmbedEvent.FilterChanged}, use `convertFilterChangedToUpdateFiltersPayload`
+     * to convert its payload into the shape expected here.
      * @version SDK: 1.23.0 | ThoughtSpot: 9.4.0.cl
      */
     HostEvent["UpdateFilters"] = "updateFilters";
@@ -4890,7 +4902,6 @@ var Param;
     Param["IsStarterPromptsEnabled"] = "enableStarterPrompts";
     Param["UpdatedSpotterExperience"] = "updatedSpotterExperience";
     Param["SpotterDataSources"] = "spotterDataSources";
-    Param["AnalystId"] = "analystId";
     Param["OpenSpotterOnLiveboardByDefault"] = "openSpotterOnLiveboardByDefault";
     Param["ShowAnswerEditPanel"] = "showAnswerEditPanel";
 })(Param || (Param = {}));
@@ -7116,6 +7127,18 @@ var Action;
      * ```
      */
     Action["DeleteCollection"] = "deleteCollection";
+    /**
+     * Controls the visibility of the "Customize homepage" button on the
+     * embedded home page.
+     * @version SDK: 1.55.0 | ThoughtSpot Cloud: 26.12.0.cl
+     * @example
+     * ```js
+     * {
+     *     hiddenActions: [Action.CustomizeHomepage],
+     * }
+     * ```
+     */
+    Action["CustomizeHomepage"] = "customizeHomepage";
 })(Action || (Action = {}));
 var PrefetchFeatures;
 (function (PrefetchFeatures) {
@@ -7620,7 +7643,7 @@ var TableContentDensity;
     TableContentDensity["Compact"] = "COMPACT";
 })(TableContentDensity || (TableContentDensity = {}));
 
-var version$1="1.52.1";var pkg = {version:version$1};
+var version$1="1.52.2-beta.0";var pkg = {version:version$1};
 
 const { version } = pkg;
 
@@ -7793,7 +7816,7 @@ const ERROR_MESSAGE = {
     SSR_ENVIRONMENT_ERROR: 'SSR environment detected. This function cannot be called in SSR environment.',
     UPDATE_PARAMS_FAILED: 'Failed to update embed parameters',
     INVALID_SPOTTER_DOCUMENTATION_URL: 'Invalid spotterDocumentationUrl. Please provide a valid http or https URL.',
-    UPDATEFILTERS_INVALID_PAYLOAD: 'UpdateFilters requires a valid filter or filters array. Expected: { filter: { column, oper, values } } or { filters: [{ column, oper, values }, ...] }',
+    UPDATEFILTERS_INVALID_PAYLOAD: 'UpdateFilters requires a valid filter or filters array. Expected: { filter: { columnName, operator, values } } or { filters: [{ columnName, operator, values }, ...] }',
     DRILLDOWN_INVALID_PAYLOAD: 'DrillDown requires a valid points object. Expected: { points: { clickedPoint?, selectedPoints? }, autoDrillDown?, vizId? }',
     UPDATEPARAMETERS_INVALID_PAYLOAD: 'UpdateParameters received an invalid applicability. Expected: { level: LIVEBOARD | TAB | GROUP, targetId } where targetId is required for TAB and GROUP levels',
 };
@@ -10756,7 +10779,7 @@ class AnswerService {
     async getTML() {
         const { object } = await this.executeQuery(getAnswerTML, {});
         const edoc = object[0].edoc;
-        const YAML = await import('./index-C1pmYb5H.js');
+        const YAML = await import('./index-BrJMbt8r.js');
         const parsedDoc = YAML.parse(edoc);
         return {
             answer: {
@@ -21665,7 +21688,8 @@ var isUndefined_1 = isUndefined;
 const isValidApplicability = (a) => {
     if (isUndefined_1(a))
         return true;
-    // targetId is not required at LIVEBOARD level, since the filter applies to the whole Liveboard
+    // targetId is not required at LIVEBOARD level, since the filter applies to
+    // the whole Liveboard
     return isPlainObject_1(a)
         && Object.values(ApplicabilityLevel).includes(a.level)
         && (a.level === ApplicabilityLevel.Liveboard || (isString_1(a.targetId) && a.targetId.trim().length > 0));
@@ -21684,8 +21708,52 @@ function isValidUpdateFiltersPayload(payload) {
     const hasValidFilters = Array.isArray(payload.filters) && payload.filters.length > 0 && payload.filters.every(isValidFilter);
     return !!(hasValidFilter || hasValidFilters);
 }
+/**
+ * Rewrites one filter's `columnName`/`operator` to `column`/`oper`.
+ *
+ * Callers may use either spelling: `columnName`/`operator` match
+ * {@link RuntimeFilter} and the `EmbedEvent.FilterChanged` payload, so a
+ * converted payload can be replayed as-is. But the payload is forwarded to the
+ * embedded app unchanged, and only `column`/`oper` are known to be understood
+ * there - so the alias must be swapped here, or it would pass validation and
+ * then be silently ignored.
+ *
+ * If a caller supplies both spellings of a field - which TypeScript rejects,
+ * but JavaScript callers can still do - the documented `columnName`/`operator`
+ * wins. Deferring to the deprecated spelling would quietly discard the value
+ * the rest of the SDK tells people to use.
+ * @param filter One entry from the UpdateFilters payload.
+ */
+function resolveFilterAliases(filter) {
+    var _a, _b;
+    if (!isPlainObject_1(filter))
+        return filter;
+    const column = (_a = filter.columnName) !== null && _a !== void 0 ? _a : filter.column;
+    const oper = (_b = filter.operator) !== null && _b !== void 0 ? _b : filter.oper;
+    const { columnName, operator, ...rest } = filter;
+    return {
+        ...rest,
+        ...(isUndefined_1(column) ? {} : { column }),
+        ...(isUndefined_1(oper) ? {} : { oper }),
+    };
+}
+/**
+ * Rewrites every filter in an UpdateFilters payload to use `column`/`oper`,
+ * whichever spelling the caller supplied. Call after validation.
+ * @param payload The UpdateFilters host event payload.
+ */
+function resolveUpdateFiltersAliases(payload) {
+    if (!isPlainObject_1(payload))
+        return payload;
+    return {
+        ...payload,
+        ...(payload.filter ? { filter: resolveFilterAliases(payload.filter) } : {}),
+        ...(Array.isArray(payload.filters) ? { filters: payload.filters.map(resolveFilterAliases) } : {}),
+    };
+}
 function isValidUpdateParametersPayload(payload) {
-    // Only validates the applicability of each parameter (null treated as absent); the rest is forwarded as-is for backward compatibility.
+    // Only validates the applicability of each parameter (null treated as
+    // absent); the rest is forwarded as-is for backward compatibility.
     if (!Array.isArray(payload))
         return true;
     return payload.every((p) => {
@@ -21733,7 +21801,8 @@ function throwUpdateParametersValidationError() {
 /**
  * Maps HostEvent to its corresponding UIPassthroughEvent.
  * Includes both custom-handler events (Pin, SaveAnswer, UpdateFilters, DrillDown)
- * and getter events (GetAnswerSession, GetFilters, etc.) that use getDataWithPassthroughFallback.
+ * and getter events (GetAnswerSession, GetFilters, etc.) that use
+ * getDataWithPassthroughFallback.
  */
 const PASSTHROUGH_MAP = {
     // Custom handlers (setters with special logic)
@@ -21884,17 +21953,21 @@ class HostEventClient {
             throwUpdateFiltersValidationError();
         }
         // The shared contract accepts both current (columnName/operator) and
-        // legacy (column/oper) filter field names — as does the validation
-        // above and the app at runtime. The UIPassthrough FilterUpdate type
-        // still requires the legacy names; bridge until that contract is
-        // audited.
-        return this.handleHostEventWithParam(UIPassthroughEvent.UpdateFilters, payload, context);
+        // legacy (column/oper) filter field names, but only the legacy pair is
+        // understood downstream, so the payload is rewritten before it is
+        // forwarded — otherwise a columnName/operator filter passes validation
+        // here and is then silently ignored by the app. The cast bridges the
+        // UIPassthrough FilterUpdate type, which still declares only the legacy
+        // names.
+        const resolvedPayload = resolveUpdateFiltersAliases(payload);
+        return this.handleHostEventWithParam(UIPassthroughEvent.UpdateFilters, resolvedPayload, context);
     }
     handleUpdateParametersEvent(payload, context) {
         if (!isValidUpdateParametersPayload(payload)) {
             throwUpdateParametersValidationError();
         }
-        // UpdateParameters has no UI passthrough contract; dispatch over the legacy channel
+        // UpdateParameters has no UI passthrough contract; dispatch over the
+        // legacy channel
         return this.hostEventFallback(HostEvent.UpdateParameters, payload, context);
     }
     handleDrillDownEvent(payload, context) {
@@ -21905,8 +21978,8 @@ class HostEventClient {
     }
     /**
      * Dispatches a host event using the appropriate channel:
-     * 1. If the embedded app supports UI passthrough for this event, use it (custom handler or getter).
-     * 2. Otherwise fall back to the legacy host event channel.
+     * 1. If the embedded app supports UI passthrough for this event, use it (custom
+     * handler or getter). 2. Otherwise fall back to the legacy host event channel.
      *
      * @param hostEvent - The host event to trigger
      * @param payload - Optional payload for the event
@@ -21915,7 +21988,8 @@ class HostEventClient {
     async triggerHostEvent(hostEvent, payload, context) {
         const customHandler = this.customHandlers[hostEvent];
         const passthroughEvent = PASSTHROUGH_MAP[hostEvent];
-        // If embedded app supports passthrough but not this event, use legacy channel
+        // If embedded app supports passthrough but not this event, use legacy
+        // channel
         const keys = passthroughEvent ? await this.getAvailableUIPassthroughKeys(context) : [];
         if (passthroughEvent && keys.length > 0 && !keys.includes(passthroughEvent)) {
             return this.hostEventFallback(hostEvent, payload, context);
@@ -22122,11 +22196,15 @@ const TS_EMBED_ID = '_thoughtspot-embed';
  */
 const PRERENDER_CONTAINER_ORIGINAL_POSITION_KEY = 'tsEmbedOriginalPosition';
 const PRERENDER_WRAPPER_ID_PREFIX = 'tsEmbed-pre-render-wrapper-';
+const PRERENDER_PARKED_TRANSFORM = 'translateY(-100%)';
+/** The height createPreRenderWrapper() seeds before anything is measured. */
+const UNMEASURED_WRAPPER_HEIGHT = '100vh';
 // The container applies UpdateEmbedParams through React state, so a delivered
 // post is not the same as the params being in effect.
 const UPDATE_EMBED_PARAMS_SETTLE_MS = 200;
-// The container ignores runtimeFilterParams/runtimeParameterParams unless truthy, so
-// null or '' leaves the previous embed's values in place. '&' is truthy and parses to {}.
+// The container ignores runtimeFilterParams/runtimeParameterParams unless
+// truthy, so null or '' leaves the previous embed's values in place. '&' is
+// truthy and parses to {}.
 const NO_RUNTIME_PARAMS = '&';
 /**
  * The event id map from v2 event names to v1 event id
@@ -22165,7 +22243,6 @@ class TsEmbed {
         this.shouldEncodeUrlQueryParams = false;
         this.defaultHiddenActions = [Action.ReportError];
         this.preRenderContainerEl = document.body;
-        this.containerScrollListener = null;
         /**
          * Handler for fullscreen change events
          */
@@ -22324,7 +22401,8 @@ class TsEmbed {
                 const AUTH_INIT_FALLBACK_DELAY = 1000;
                 // Wait for 1 second to ensure the embed container is loaded
                 // This is a workaround to ensure the embed container is loaded
-                // this is needed until all clusters have EmbedListenerReady event
+                // this is needed until all clusters have EmbedListenerReady
+                // event
                 setTimeout(processEmbedContainerReady, AUTH_INIT_FALLBACK_DELAY);
             }
             else if (source === EmbedEvent.EmbedListenerReady) {
@@ -22332,7 +22410,8 @@ class TsEmbed {
             }
         };
         // Subclasses that navigate the pre-render on show must await this before
-        // triggering Navigate. Resolves even on failure, so navigation is never blocked.
+        // triggering Navigate. Resolves even on failure, so navigation is never
+        // blocked.
         this.preRenderParamsApplied = Promise.resolve();
         this.hostElement = getDOMNode(domSelector);
         this.eventHandlerMap = new Map();
@@ -22662,8 +22741,9 @@ class TsEmbed {
             ...this.viewConfig,
             ...queryParams,
             ...appInitData,
-            // A show cycle has no URL to carry these, so the payload always states them
-            // — including "none", which is the case that leaks the previous filters.
+            // A show cycle has no URL to carry these, so the payload always
+            // states them — including "none", which is the case that leaks the
+            // previous filters.
             runtimeFilterParams: getFilterQuery((_a = this.viewConfig.runtimeFilters) !== null && _a !== void 0 ? _a : []) || NO_RUNTIME_PARAMS,
             runtimeParameterParams: getRuntimeParameters((_b = this.viewConfig.runtimeParameters) !== null && _b !== void 0 ? _b : [])
                 || NO_RUNTIME_PARAMS,
@@ -23008,7 +23088,7 @@ class TsEmbed {
             top: '0',
             left: '0',
             width: '100vw',
-            height: '100vh',
+            height: UNMEASURED_WRAPPER_HEIGHT,
         };
         setStyleProperties(preRenderWrapper, initialPreRenderWrapperStyle);
         return preRenderWrapper;
@@ -23076,10 +23156,26 @@ class TsEmbed {
         return placeholder;
     }
     /**
-     * Resolves the configured preRenderContainer to a live element, falling
-     * back to `document.body`. A string selector is re-queried on every call so
-     * a remounted container (E.g.: React replacing the node) resolves to the
-     * fresh element; an element passed directly cannot be re-resolved.
+     * Resolves the configured preRenderContainer to a live element. A string
+     * selector is re-queried on every call so a remounted container (E.g.: React
+     * replacing the node) resolves to the fresh element; an element passed
+     * directly cannot be re-resolved.
+     *
+     * With nothing configured the frame goes into the host element's nearest
+     * scrolling ancestor, falling back to `document.body`.
+     *
+     * The wrapper is absolutely positioned, so it follows the page for free —
+     * but only while it sits inside whatever scrolls. `document.body` is right
+     * only when the document itself is the scroller; an app that scrolls an
+     * inner element instead left the frame pinned to the viewport while the page
+     * moved under it (SCAL-338563). Being inside the scroller also lets wheel
+     * events chain out of the frame into it, which they cannot do from
+     * `document.body`.
+     *
+     * A scrolling ancestor is layout chrome rather than route content, so it
+     * outlives the embed in practice; and if it does go, the host element goes
+     * with it and this instance is remounting anyway.
+     * `reconcilePreRenderContainer` re-runs this on a detached container.
      */
     resolvePreRenderContainerTarget() {
         var _a;
@@ -23099,7 +23195,13 @@ class TsEmbed {
         else if (containerConfig) {
             container = containerConfig;
         }
-        return (_a = container) !== null && _a !== void 0 ? _a : document.body;
+        if (container) {
+            return container;
+        }
+        if (!this.hostElement) {
+            return document.body;
+        }
+        return (_a = getScrollableAncestors(this.hostElement)[0]) !== null && _a !== void 0 ? _a : document.body;
     }
     inheritPreRenderContainer() {
         var _a;
@@ -23144,8 +23246,9 @@ class TsEmbed {
      * Re-attaches the wrapper to a live container when the previously resolved
      * one has been detached or no longer holds the wrapper — e.g. the host app
      * remounted a custom preRenderContainer, which would otherwise leave a stale
-     * reference and collapse the wrapper. Only string selectors can be
-     * re-resolved; a container passed as an element is left untouched.
+     * reference and collapse the wrapper. Selectors and the auto-resolved
+     * scrolling ancestor are both re-resolved; a container passed as an element
+     * is left untouched, as there is nothing to re-query.
      */
     reconcilePreRenderContainer() {
         const wrapper = this.preRenderWrapper;
@@ -23164,14 +23267,6 @@ class TsEmbed {
         if (resolved === stored && stored.contains(wrapper)) {
             return;
         }
-        if (this.containerScrollListener && stored !== resolved) {
-            if (stored !== document.body) {
-                stored.removeEventListener('scroll', this.containerScrollListener);
-            }
-            if (resolved !== document.body) {
-                resolved.addEventListener('scroll', this.containerScrollListener);
-            }
-        }
         this.preRenderContainerEl = resolved;
         this.applyPreRenderContainerPositioning();
         if (wrapper.parentNode !== resolved) {
@@ -23233,11 +23328,12 @@ class TsEmbed {
      */
     setIFrameHeight(height) {
         if (this.isPreRendered) {
+            const next = getCssDimension(height);
             if (this.insertedDomEl) {
-                this.insertedDomEl.style.height = getCssDimension(height);
+                this.insertedDomEl.style.height = next;
             }
             else if (this.preRenderWrapper) {
-                this.preRenderWrapper.style.height = getCssDimension(height);
+                this.preRenderWrapper.style.height = next;
             }
         }
         else {
@@ -23390,8 +23486,9 @@ class TsEmbed {
             return;
         this.preRenderWrapper[this.embedNodeKey] = this;
     }
-    // The flag lives on the wrapper because it describes the iframe: an instance
-    // hidden when the container announced itself would otherwise report false forever.
+    // The flag lives on the wrapper because it describes the iframe: an
+    // instance hidden when the container announced itself would otherwise
+    // report false forever.
     markEmbedContainerLoaded() {
         this.isEmbedContainerLoaded = true;
         if (this.preRenderWrapper) {
@@ -23671,34 +23768,47 @@ class TsEmbed {
         delete container.dataset[PRERENDER_CONTAINER_ORIGINAL_POSITION_KEY];
     }
     /**
-     * Detaches and clears the container scroll listener, if one is attached.
-     */
-    removeContainerScrollListener() {
-        if (!this.containerScrollListener) {
+     * Re-sizes the wrapper when its placeholder changes size.
+     *
+     * Position deliberately has no equivalent. An absolutely positioned wrapper
+     * follows its containing block for free, so a correctly placed frame is the
+     * browser's job and costs nothing; repositioning it on scroll would mean a
+     * layout read and a style write per frame to compensate for placing it in
+     * the wrong box. Size is the one thing the browser will not do for us: the
+     * placeholder grows when the embedded app reports a new height, and the
+     * wrapper has to be told.
+     */
+    observePreRenderSize() {
+        var _a;
+        if (this.getPreRenderConfig().doNotTrackSize || typeof ResizeObserver === 'undefined') {
+            return;
+        }
+        const placeholder = this.getPreRenderPlaceHolderElement();
+        if (!placeholder) {
             return;
         }
-        const customContainer = this.getCustomPreRenderContainer();
-        customContainer === null || customContainer === void 0 ? void 0 : customContainer.removeEventListener('scroll', this.containerScrollListener);
-        this.containerScrollListener = null;
+        (_a = this.resizeObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
+        this.resizeObserver = new ResizeObserver(() => this.syncPreRenderStyle());
+        this.resizeObserver.observe(placeholder);
     }
     /**
      * Destroys the ThoughtSpot embed, and remove any nodes from the DOM.
      * @version SDK: 1.19.1 | ThoughtSpot: *
      */
     destroy() {
-        var _a, _b, _c;
+        var _a, _b, _c, _d;
         try {
             this.removeFullscreenChangeHandler();
-            this.removeContainerScrollListener();
+            (_a = this.resizeObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
             this.unsubscribeToEvents();
-            (_a = this.preRenderWrapper) === null || _a === void 0 ? void 0 : _a.remove();
+            (_b = this.preRenderWrapper) === null || _b === void 0 ? void 0 : _b.remove();
             this.restorePreRenderContainerPosition();
             if (!this.isRendered) {
                 return;
             }
             if (!getEmbedConfig().waitForCleanupOnDestroy) {
                 this.trigger(HostEvent.DestroyEmbed);
-                (_c = (_b = this.insertedDomEl) === null || _b === void 0 ? void 0 : _b.parentNode) === null || _c === void 0 ? void 0 : _c.removeChild(this.insertedDomEl);
+                (_d = (_c = this.insertedDomEl) === null || _c === void 0 ? void 0 : _c.parentNode) === null || _d === void 0 ? void 0 : _d.removeChild(this.insertedDomEl);
             }
             else {
                 const cleanupTimeout = getEmbedConfig().cleanupTimeout;
@@ -23779,7 +23889,7 @@ class TsEmbed {
      * wrapper to overlay it.
      */
     async showPreRender() {
-        var _a, _b;
+        var _a;
         uploadMixpanelEvent(MIXPANEL_EVENT.VISUAL_SDK_SHOW_PRE_RENDER, {
             preRenderId: this.getPreRenderConfig().id,
             embedComponentType: this.viewConfig.embedComponentType,
@@ -23798,54 +23908,49 @@ class TsEmbed {
         this.beforePrerenderVisible();
         if (this.hostElement) {
             this.insertedDomEl = this.createPreRenderPlaceholder();
-            if (this.viewConfig.fullHeight) {
-                // If fullHeight has already sized the wrapper, seed the placeholder
-                // with the same height so syncPreRenderStyle gets an accurate rect.
-                const existingHeight = this.preRenderWrapper.style.height;
-                if (existingHeight) {
-                    this.insertedDomEl.style.height = existingHeight;
-                }
+            // Carry a height fullHeight has already measured onto the fresh
+            // placeholder, so a re-show does not flash at frameParams height.
+            // UNMEASURED_WRAPPER_HEIGHT is what createPreRenderWrapper() seeds
+            // before anything has been measured; treating that as a measurement
+            // is what made a first reveal overshoot to a full viewport.
+            const wrapperHeight = this.preRenderWrapper.style.height;
+            if (this.viewConfig.fullHeight
+                && wrapperHeight
+                && wrapperHeight !== UNMEASURED_WRAPPER_HEIGHT) {
+                this.insertedDomEl.style.height = wrapperHeight;
             }
             const placeHolderId = this.getPreRenderIds().placeHolder;
             // Remove any stale placeholder from a previous cycle. It is located
-            // via a subtree-wide querySelector, so it may be nested deeper than a
-            // direct child (E.g.: with fullHeight the host app can wrap it). Use
-            // Element.remove() — which detaches from whatever the real parent is —
-            // rather than hostElement.removeChild(), which throws NotFoundError
-            // when the match is not a direct child. Mirrors the wrapper/child
-            // cleanup in createPreRenderWrapper()/createPreRenderChild().
+            // via a subtree-wide querySelector, so it may be nested deeper
+            // than a direct child (E.g.: with fullHeight the host app can wrap
+            // it). Use Element.remove() — which detaches from whatever the real
+            // parent is — rather than hostElement.removeChild(), which throws
+            // NotFoundError when the match is not a direct child. Mirrors the
+            // wrapper/child cleanup in
+            // createPreRenderWrapper()/createPreRenderChild().
             (_a = this.hostElement.querySelector(`#${placeHolderId}`)) === null || _a === void 0 ? void 0 : _a.remove();
             this.hostElement.appendChild(this.insertedDomEl);
             this.syncPreRenderStyle();
-            const customContainer = this.getCustomPreRenderContainer();
-            if (customContainer && !this.containerScrollListener) {
-                this.containerScrollListener = () => this.syncPreRenderStyle();
-                customContainer.addEventListener('scroll', this.containerScrollListener);
-            }
-            if (!this.getPreRenderConfig().doNotTrackSize) {
-                const observeTarget = (_b = this.insertedDomEl) !== null && _b !== void 0 ? _b : this.hostElement;
-                this.resizeObserver = new ResizeObserver((entries) => {
-                    entries.forEach((entry) => {
-                        if (entry.target === observeTarget) {
-                            this.syncPreRenderStyle();
-                        }
-                    });
-                });
-                this.resizeObserver.observe(observeTarget);
-            }
+            this.observePreRenderSize();
         }
         removeStyleProperties(this.preRenderWrapper, [
             'z-index',
             'opacity',
-            'pointer-events',
             'overflow',
+            'transform',
         ]);
+        // Set rather than removed: a container that carries `pointer-events:
+        // none` — the usual styling for a parking root that must not swallow
+        // clicks — passes it down, and dropping the property here would leave
+        // the inherited `none` in force and the frame dead to input.
+        setStyleProperties(this.preRenderWrapper, { pointerEvents: 'auto' });
         this.subscribeToEvents();
         // Setup fullscreen change handler for prerendered components
         if (this.iFrame) {
             this.setupFullscreenChangeHandler();
         }
-        // Last, so everything above still sees the instance being taken over from.
+        // Last, so everything above still sees the instance being taken over
+        // from.
         this.takeOverPreRender();
         return this;
     }
@@ -23891,6 +23996,7 @@ class TsEmbed {
      * If the component is not preRendered, it issues a warning.
      */
     hidePreRender() {
+        var _a;
         uploadMixpanelEvent(MIXPANEL_EVENT.VISUAL_SDK_HIDE_PRE_RENDER, {
             preRenderId: this.getPreRenderConfig().id,
             embedComponentType: this.viewConfig.embedComponentType,
@@ -23910,12 +24016,15 @@ class TsEmbed {
             top: '0',
             left: '0',
             overflow: 'hidden',
+            // Keeps the measured size — so the next show needs no resize, which
+            // is the point of pre-rendering — while lifting the box out of
+            // the container's scrollable area. Overflow only extends
+            // downwards, so a hidden frame parked above the top edge adds
+            // none, where one left at full height shows as blank scroll space.
+            transform: PRERENDER_PARKED_TRANSFORM,
         };
         setStyleProperties(this.preRenderWrapper, preRenderHideStyles);
-        this.removeContainerScrollListener();
-        if (this.resizeObserver) {
-            this.resizeObserver.disconnect();
-        }
+        (_a = this.resizeObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
         const placeHolderEle = this.getPreRenderPlaceHolderElement();
         if (placeHolderEle) {
             placeHolderEle.parentElement.removeChild(placeHolderEle);
@@ -24132,6 +24241,18 @@ function buildStarterPromptsAppInitData(initData, viewConfig) {
             starterPrompts,
         },
     };
+}
+function buildSpotterAnalystAppInitData(initData, viewConfig) {
+    const { spotterAnalystConfig } = viewConfig;
+    if (!(spotterAnalystConfig === null || spotterAnalystConfig === void 0 ? void 0 : spotterAnalystConfig.analystId))
+        return initData;
+    return {
+        ...initData,
+        embedParams: {
+            ...(initData.embedParams || {}),
+            spotterAnalystConfig,
+        },
+    };
 }
 
 function buildSpotterVizAppInitData(initData, viewConfig) {
@@ -24725,8 +24846,9 @@ const addPreviewStylesIfNotPresent = () => {
  * @summary Liveboard & visualization embed
  * @author Ayon Ghosh <ayon.ghosh@thoughtspot.com>
  */
-// Home unmounts the liveboard container, which is how its state gets cleared. The
-// settle window gives the container time to do it before we ask for the liveboard back.
+// Home unmounts the liveboard container, which is how its state gets cleared.
+// The settle window gives the container time to do it before we ask for the
+// liveboard back.
 const HOME_ROUTE = 'home';
 const HOME_SETTLE_MS = 200;
 /**
@@ -25024,21 +25146,24 @@ class LiveboardEmbed extends V1Embed {
     }
     beforePrerenderVisible() {
         super.beforePrerenderVisible();
-        // Captured before showPreRender() hands the wrapper over to this instance.
-        // Itself means a hide/show, not a hand-over, so there is nothing stale to clear.
+        // Captured before showPreRender() hands the wrapper over to this
+        // instance. Itself means a hide/show, not a hand-over, so there is
+        // nothing stale to clear.
         const previous = this.getPreRenderObj();
         const showing = previous === this ? undefined : previous === null || previous === void 0 ? void 0 : previous.currentLiveboardState;
         this.executeAfterEmbedContainerLoaded(async () => {
-            // Without this the params callback suspends on its await and Navigate
-            // goes out first, so the container loads with the previous config's filters.
+            // Without this the params callback suspends on its await and
+            // Navigate goes out first, so the container loads with the previous
+            // config's filters.
             await this.preRenderParamsApplied;
             if (this.isShowingLiveboardRoute(showing)) {
-                // Navigate to the route we are already on is a no-op, so the liveboard
-                // keeps its state. Home unmounts the container, which clears it.
+                // Navigate to the route we are already on is a no-op, so the
+                // liveboard keeps its state. Home unmounts the container, which
+                // clears it.
                 this.trigger(HostEvent.Navigate, HOME_ROUTE)
                     .catch((error) => logger$3.warn('Could not route via home', error));
-                // Not awaited above: the container never acks Navigate, so that promise
-                // only settles on the 30s trigger timeout.
+                // Not awaited above: the container never acks Navigate, so
+                // that promise only settles on the 30s trigger timeout.
                 await new Promise((resolve) => {
                     setTimeout(resolve, HOME_SETTLE_MS);
                 });
@@ -25052,8 +25177,9 @@ class LiveboardEmbed extends V1Embed {
             };
         });
     }
-    // The whole route, not just the liveboard id: the path is built from the viz, tab
-    // and view too, so a same-liveboard show onto another tab is a real navigation.
+    // The whole route, not just the liveboard id: the path is built from the
+    // viz, tab and view too, so a same-liveboard show onto another tab is a
+    // real navigation.
     isShowingLiveboardRoute(showing) {
         if (!(showing === null || showing === void 0 ? void 0 : showing.liveboardId))
             return false;
@@ -26003,10 +26129,11 @@ class SpotterEmbed extends TsEmbed {
         const defaultAppInitData = await super.getAppInitData();
         const sidebarInitData = buildSpotterSidebarAppInitData(defaultAppInitData, this.viewConfig, this.handleError.bind(this));
         const shareInitData = buildSpotterShareConversationAppInitData(sidebarInitData, this.viewConfig);
-        return buildStarterPromptsAppInitData(shareInitData, this.viewConfig);
+        const starterPromptsInitData = buildStarterPromptsAppInitData(shareInitData, this.viewConfig);
+        return buildSpotterAnalystAppInitData(starterPromptsInitData, this.viewConfig);
     }
     getEmbedParamsObject() {
-        const { searchOptions, disableSourceSelection, hideSourceSelection, dataPanelV2, updatedSpotterExperience, showSpotterLimitations, hideSampleQuestions, runtimeFilters, excludeRuntimeFiltersfromURL, runtimeParameters, excludeRuntimeParametersfromURL, updatedSpotterChatPrompt, showSpotterRadiance, defaultQueryMode, enableStopAnswerGenerationEmbed, spotterChatConfig, spotterAnalystConfig, } = this.viewConfig;
+        const { searchOptions, disableSourceSelection, hideSourceSelection, dataPanelV2, updatedSpotterExperience, showSpotterLimitations, hideSampleQuestions, runtimeFilters, excludeRuntimeFiltersfromURL, runtimeParameters, excludeRuntimeParametersfromURL, updatedSpotterChatPrompt, showSpotterRadiance, defaultQueryMode, enableStopAnswerGenerationEmbed, spotterChatConfig, } = this.viewConfig;
         const queryParams = this.getBaseQueryParams();
         queryParams[Param.SpotterEnabled] = true;
         // Boolean params
@@ -26019,7 +26146,6 @@ class SpotterEmbed extends TsEmbed {
         setParamIfDefined(queryParams, Param.ShowSpotterRadiance, showSpotterRadiance, true);
         setParamIfDefined(queryParams, Param.DefaultQueryMode, defaultQueryMode);
         setParamIfDefined(queryParams, Param.EnableStopAnswerGenerationEmbed, enableStopAnswerGenerationEmbed, true);
-        setParamIfDefined(queryParams, Param.AnalystId, spotterAnalystConfig === null || spotterAnalystConfig === void 0 ? void 0 : spotterAnalystConfig.analystId);
         // Handle spotterChatConfig params
         if (spotterChatConfig) {
             const { hideToolResponseCardBranding, toolResponseCardBrandingLabel, spotterFileUploadEnabled, spotterFileUploadFileTypes, enableStarterPrompts, } = spotterChatConfig;
@@ -26626,6 +26752,213 @@ const createLiveboardWithAnswers = async (answers, name) => {
     return result;
 };
 
+/**
+ * Copyright (c) 2026
+ *
+ * Utility to convert the payload emitted by `EmbedEvent.FilterChanged`
+ * into the payload shape expected by `HostEvent.UpdateFilters`, so that
+ * the current filter state of a Liveboard can be captured and re-applied
+ * later without having to hand-parse the event payload.
+ * @summary Filter payload converter
+ */
+/**
+ * Coerces an epoch/count field to a number, returning `null` when the value is
+ * absent or not a finite number. The payload arrives as JSON from the iframe,
+ * so a missing field can be `null` as well as `undefined`, and `Number(null)`
+ * or `Number('')` would otherwise silently become a valid-looking `0`
+ * (i.e. the Unix epoch, or a zero-length period).
+ * @param value Raw value from the date filter payload.
+ */
+function toFiniteNumber(value) {
+    if (isNil_1(value) || value === '')
+        return null;
+    const numericValue = Number(value);
+    return Number.isFinite(numericValue) ? numericValue : null;
+}
+const DATE_FILTER_VALUE_EXTRACTORS = {
+    EXACT_DATE: (dateFilter) => {
+        const epoch = toFiniteNumber(dateFilter.epoch);
+        return epoch === null ? [] : [epoch];
+    },
+    EXACT_DATE_RANGE: (dateFilter) => {
+        var _a;
+        const { lowEpoch, highEpoch } = (_a = dateFilter.dateRange) !== null && _a !== void 0 ? _a : {};
+        const low = toFiniteNumber(lowEpoch);
+        const high = toFiniteNumber(highEpoch);
+        return low === null || high === null ? [] : [low, high];
+    },
+    MONTH_YEAR: (dateFilter) => (dateFilter.monthName && dateFilter.yearName
+        ? [dateFilter.monthName, dateFilter.yearName]
+        : []),
+    QUARTER_YEAR: (dateFilter) => (dateFilter.quarterName && dateFilter.yearName
+        ? [dateFilter.quarterName, dateFilter.yearName]
+        : []),
+    YEAR_ONLY: (dateFilter) => (dateFilter.yearName ? [dateFilter.yearName] : []),
+    LAST_N_PERIOD: (dateFilter) => {
+        const count = toFiniteNumber(dateFilter.number);
+        return count === null ? [] : [count];
+    },
+    NEXT_N_PERIOD: (dateFilter) => {
+        const count = toFiniteNumber(dateFilter.number);
+        return count === null ? [] : [count];
+    },
+};
+// Date filter types with no `values` (e.g. TODAY needs no operand).
+const PERIOD_ONLY_DATE_FILTER_TYPES = new Set([
+    'THIS_PERIOD', 'PERIOD_TO_DATE', 'TODAY', 'YESTERDAY', 'TOMORROW',
+]);
+function convertDateFilterToParam(columnName, dateFilterContent) {
+    var _a;
+    const dateFilter = dateFilterContent === null || dateFilterContent === void 0 ? void 0 : dateFilterContent.dateFilter;
+    if (!(dateFilter === null || dateFilter === void 0 ? void 0 : dateFilter.type))
+        return null;
+    let values;
+    const getValues = DATE_FILTER_VALUE_EXTRACTORS[dateFilter.type];
+    if (getValues) {
+        values = getValues(dateFilter);
+        // Required fields (e.g. epoch, yearName) are missing - the source data
+        // can't be reconstructed faithfully, so skip rather than emit a filter
+        // that would clear/corrupt this column when re-applied.
+        if (values.length === 0)
+            return null;
+    }
+    else if (PERIOD_ONLY_DATE_FILTER_TYPES.has(dateFilter.type)) {
+        values = [];
+    }
+    else {
+        // Unrecognized date filter type - skip rather than guess.
+        return null;
+    }
+    const param = {
+        columnName,
+        operator: (_a = dateFilter.op) !== null && _a !== void 0 ? _a : RuntimeFilterOp.EQ,
+        values,
+        type: dateFilter.type,
+    };
+    if (dateFilter.datePeriod) {
+        param.datePeriod = dateFilter.datePeriod;
+    }
+    if (!isNil_1(dateFilter.includeCurrentPeriod)) {
+        param.includeCurrentPeriod = dateFilter.includeCurrentPeriod;
+    }
+    if (dateFilterContent.negate) {
+        param.negate = true;
+    }
+    return param;
+}
+function convertFilterContentToParam(columnName, filterContent) {
+    var _a;
+    if (!(filterContent === null || filterContent === void 0 ? void 0 : filterContent.filterType))
+        return null;
+    const values = ((_a = filterContent.value) !== null && _a !== void 0 ? _a : [])
+        .map((value) => value === null || value === void 0 ? void 0 : value.key)
+        .filter((value) => !isNil_1(value));
+    const param = {
+        columnName,
+        operator: filterContent.filterType,
+        values,
+    };
+    if (filterContent.negate) {
+        param.negate = true;
+    }
+    return param;
+}
+function convertFilterToParams(columnName, filter) {
+    var _a, _b;
+    const dateParams = ((_a = filter === null || filter === void 0 ? void 0 : filter.dateFilterContent) !== null && _a !== void 0 ? _a : [])
+        .map((dateFilterContent) => convertDateFilterToParam(columnName, dateFilterContent));
+    const contentParams = ((_b = filter === null || filter === void 0 ? void 0 : filter.filterContent) !== null && _b !== void 0 ? _b : [])
+        .map((filterContent) => convertFilterContentToParam(columnName, filterContent));
+    return [...dateParams, ...contentParams]
+        .filter((param) => param !== null);
+}
+/**
+ * Runtime filters need no reshaping, but they still come off the wire as JSON,
+ * so a malformed entry is possible. Skip it rather than pass it through: an
+ * entry missing a column, operator or values array fails
+ * `isValidUpdateFiltersPayload`, and that rejects the *whole* `filters` array,
+ * so one bad runtime filter would drop every other converted filter with it.
+ * @param runtimeFilter A runtime filter from the `FilterChanged` payload.
+ */
+function convertRuntimeFilterToParam(runtimeFilter) {
+    const { columnName, operator, values } = runtimeFilter !== null && runtimeFilter !== void 0 ? runtimeFilter : {};
+    if (typeof columnName !== 'string' || !columnName)
+        return null;
+    if (typeof operator !== 'string' || !operator)
+        return null;
+    if (!Array.isArray(values))
+        return null;
+    return { columnName, operator, values };
+}
+/**
+ * Mirrors `isValidApplicability` in `hostEventClient/utils`: a `TAB` or `GROUP`
+ * scope is meaningless without a `targetId`, and `UpdateFilters` rejects the
+ * whole `filters` array when any entry carries a malformed `applicability`.
+ * @param applicability Scope taken from the `FilterChanged` payload.
+ */
+function isUsableApplicability(applicability) {
+    const levels = Object.values(ApplicabilityLevel);
+    if (!levels.includes(applicability.level))
+        return false;
+    if (applicability.level === ApplicabilityLevel.Liveboard)
+        return true;
+    return typeof applicability.targetId === 'string' && applicability.targetId.trim().length > 0;
+}
+function convertFilterGroupToParams(filterGroup) {
+    var _a, _b;
+    const columnName = (_a = filterGroup === null || filterGroup === void 0 ? void 0 : filterGroup.columnInfo) === null || _a === void 0 ? void 0 : _a.name;
+    if (!columnName)
+        return [];
+    const { applicability } = filterGroup;
+    // A filter scoped to a tab or group has to keep that scope. Replaying it
+    // without `applicability` would silently widen it to the whole Liveboard,
+    // changing what every other tab shows. If a scope is present but unusable,
+    // skip the filter: widening is worse than dropping, and a malformed
+    // applicability would fail validation for every other filter alongside it.
+    if (!isNil_1(applicability) && !isUsableApplicability(applicability))
+        return [];
+    const params = ((_b = filterGroup.filters) !== null && _b !== void 0 ? _b : [])
+        .flatMap((filter) => convertFilterToParams(columnName, filter));
+    return isNil_1(applicability) ? params : params.map((param) => ({ ...param, applicability }));
+}
+/**
+ * Converts the payload emitted by {@link EmbedEvent.FilterChanged} into the
+ * payload shape expected by {@link HostEvent.UpdateFilters}, so the same
+ * filter state can be captured and re-applied later, for example on a
+ * subsequent page load.
+ *
+ * Both the Liveboard filters and the runtime filters present in the
+ * `FilterChanged` payload are included in the returned `filters` array.
+ *
+ * Note: a column with multiple date-filter conditions (e.g. an OR of two
+ * date ranges) is not guaranteed to round-trip losslessly - `HostEvent.UpdateFilters`
+ * treats date filters as replace-not-merge per column, so only the last
+ * converted entry for such a column will apply.
+ * @param filterChangedPayload The filter state carried by the
+ * `EmbedEvent.FilterChanged` callback, which is `payload.data` - the
+ * callback argument is the event envelope, and the filters sit under its
+ * `data` key.
+ * @example
+ * ```js
+ * let savedFilters;
+ * liveboardEmbed.on(EmbedEvent.FilterChanged, (payload) => {
+ *     savedFilters = convertFilterChangedToUpdateFiltersPayload(payload.data);
+ * });
+ *
+ * // later, e.g. after a fresh page load
+ * liveboardEmbed.trigger(HostEvent.UpdateFilters, savedFilters);
+ * ```
+ */
+function convertFilterChangedToUpdateFiltersPayload(filterChangedPayload) {
+    var _a, _b;
+    const liveboardFilterParams = ((_a = filterChangedPayload === null || filterChangedPayload === void 0 ? void 0 : filterChangedPayload.liveboardFilters) !== null && _a !== void 0 ? _a : [])
+        .flatMap(convertFilterGroupToParams);
+    const runtimeFilterParams = ((_b = filterChangedPayload === null || filterChangedPayload === void 0 ? void 0 : filterChangedPayload.runtimeFilters) !== null && _b !== void 0 ? _b : [])
+        .map(convertRuntimeFilterToParam)
+        .filter((param) => param !== null);
+    return { filters: [...liveboardFilterParams, ...runtimeFilterParams] };
+}
+
 /**
  * Starts an automatic renderer that watches the DOM for iframes containing
  * the `tsmcp=true` query parameter and replaces them with fully configured
@@ -26769,4 +27102,4 @@ class AutoFrameRenderer extends TsEmbed {
     }
 }
 
-export { Action, AnswerService, AppEmbed, ApplicabilityLevel, AuthEvent, AuthFailureType, AuthStatus, AuthType, BackgroundFormatType, BodylessConversation, ConditionalFormattingComparisonType, ConditionalFormattingOperator, ContextMenuTriggerOptions, ContextType, ConversationEmbed, CustomActionTarget, CustomActionsPosition, DataLabelFilterOperator, DataPanelCustomColumnGroupsAccordionState$1 as DataPanelCustomColumnGroupsAccordionState, DataSourceVisualMode, EmbedErrorCodes, EmbedErrorSeverity, EmbedEvent, ErrorDetailsTypes, HomeLeftNavItem, HomePage, HomePageSearchBarMode, HomepageModule, HostEvent, InterceptedApiType, LegendPosition, ListPage, ListPageColumns, LiveboardEmbed, LogLevel, MIXPANEL_EVENT, Page, PinboardEmbed, PrefetchFeatures, PrimaryNavbarVersion, RuntimeFilterOp, SearchBarEmbed, SearchEmbed, SpotterAgentEmbed, SpotterEmbed, SpotterQueryMode, TableContentDensity, TableTheme, UIPassthroughEvent, createLiveboardWithAnswers, executeTML, exportTML, getAnswerFromQuery, getEmbedConfig as getInitConfig, getSessionInfo, init, logout, prefetch, reloadIframe, resetCachedAuthToken, startAutoMCPFrameRenderer, tokenizedFetch, uploadMixpanelEvent };
+export { Action, AnswerService, AppEmbed, ApplicabilityLevel, AuthEvent, AuthFailureType, AuthStatus, AuthType, BackgroundFormatType, BodylessConversation, ConditionalFormattingComparisonType, ConditionalFormattingOperator, ContextMenuTriggerOptions, ContextType, ConversationEmbed, CustomActionTarget, CustomActionsPosition, DataLabelFilterOperator, DataPanelCustomColumnGroupsAccordionState$1 as DataPanelCustomColumnGroupsAccordionState, DataSourceVisualMode, EmbedErrorCodes, EmbedErrorSeverity, EmbedEvent, ErrorDetailsTypes, HomeLeftNavItem, HomePage, HomePageSearchBarMode, HomepageModule, HostEvent, InterceptedApiType, LegendPosition, ListPage, ListPageColumns, LiveboardEmbed, LogLevel, MIXPANEL_EVENT, Page, PinboardEmbed, PrefetchFeatures, PrimaryNavbarVersion, RuntimeFilterOp, SearchBarEmbed, SearchEmbed, SpotterAgentEmbed, SpotterEmbed, SpotterQueryMode, TableContentDensity, TableTheme, UIPassthroughEvent, convertFilterChangedToUpdateFiltersPayload, createLiveboardWithAnswers, executeTML, exportTML, getAnswerFromQuery, getEmbedConfig as getInitConfig, getSessionInfo, init, logout, prefetch, reloadIframe, resetCachedAuthToken, startAutoMCPFrameRenderer, tokenizedFetch, uploadMixpanelEvent };