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

package/src/embed/hostEventClient/utils.ts

@@ -10,7 +10,8 @@ import { embedEventStatus } from '../../utils';
 
 const isValidApplicability = (a?: { level?: string; targetId?: string }) => {
   if (isUndefined(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(a)
       && Object.values(ApplicabilityLevel).includes(a.level as ApplicabilityLevel)
       && (a.level === ApplicabilityLevel.Liveboard || (isString(a.targetId) && a.targetId.trim().length > 0));
@@ -44,8 +45,56 @@ export function isValidUpdateFiltersPayload(
   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<T extends { column?: string; columnName?: string; oper?: string; operator?: string }>(
+  filter: T,
+): T {
+  if (!isPlainObject(filter)) return filter;
+
+  const column = filter.columnName ?? filter.column;
+  const oper = filter.operator ?? filter.oper;
+  const { columnName, operator, ...rest } = filter;
+
+  return {
+    ...rest,
+    ...(isUndefined(column) ? {} : { column }),
+    ...(isUndefined(oper) ? {} : { oper }),
+  } as T;
+}
+
+/**
+ * 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.
+ */
+export function resolveUpdateFiltersAliases<T extends { filter?: any; filters?: any[] }>(payload: T): T {
+  if (!isPlainObject(payload)) return payload;
+
+  return {
+    ...payload,
+    ...(payload.filter ? { filter: resolveFilterAliases(payload.filter) } : {}),
+    ...(Array.isArray(payload.filters) ? { filters: payload.filters.map(resolveFilterAliases) } : {}),
+  };
+}
+
 export function isValidUpdateParametersPayload(payload: unknown): boolean {
-  // 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) => {
       if (!isPlainObject(p)) return true;

package/src/embed/liveboard.spec.ts

@@ -3054,8 +3054,8 @@ describe('LiveboardEmbed updatedSpotterExperience tests', () => {
 
     describe('trigger typing contracts (compile-time)', () => {
         // Enforced by ts-jest at compile time. LiveboardEmbed OVERRIDES
-        // TsEmbed.trigger, so its generic defaults must be asserted separately —
-        // a bare `PayloadT` on the override silently collapses no-payload
+        // TsEmbed.trigger, so its generic defaults must be asserted separately
+        // — a bare `PayloadT` on the override silently collapses no-payload
         // responses back to `any` for every LiveboardEmbed consumer.
         type IsAny<T> = 0 extends 1 & T ? true : false;
         type Extends<A, B> = A extends B ? true : false;
@@ -3073,7 +3073,8 @@ describe('LiveboardEmbed updatedSpotterExperience tests', () => {
                 { numberOfTabs: number; orderedTabIds: string[] }
             > = true;
             const probeUnknownField = (r: TabsResponse) =>
-                // @ts-expect-error — field not on the GetTabs contract (was silent when `any`)
+                // @ts-expect-error — field not on the GetTabs contract (was
+                // silent when `any`)
                 r.tabCount;
             void probeUnknownField;
 

package/src/embed/liveboard.ts

@@ -37,8 +37,9 @@ import { SpotterChatViewConfig, StarterPromptsConfig } from './conversation';
 import { buildStarterPromptsAppInitData } from './spotter-utils';
 import { SpotterVizConfig, buildSpotterVizAppInitData } from './spotter-viz-utils';
 
-// 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;
 
@@ -354,9 +355,10 @@ export interface LiveboardViewConfig
      */
     isPNGInScheduledEmailsEnabled?: boolean;
     /**
-     * Enables the 'what you see is what you get' PDF export for Liveboards. Each tab is rendered on a single page
-     * following the exact UI layout, instead of splitting visualizations across multiple A4 pages.
-     * This feature is GA from SDK version 1.51.0 and ThoughtSpot version 26.8.0.cl.
+     * Enables the 'what you see is what you get' PDF export for Liveboards. Each tab is
+     * rendered on a single page following the exact UI layout, instead of splitting
+     * visualizations across multiple A4 pages. This feature is GA from SDK version
+     * 1.51.0 and ThoughtSpot version 26.8.0.cl.
      *
      * Supported embed types: `AppEmbed`, `LiveboardEmbed`
      * @type {boolean}
@@ -597,7 +599,7 @@ export class LiveboardEmbed extends V1Embed {
      * embedded Liveboard or visualization.
      */
     protected getEmbedParams() {
-        const params = this.getEmbedParamsObject();
+        const params = this.getUrlQueryParamsObject();
         const queryParams = getQueryParamString(params, true);
         return queryParams;
     }
@@ -952,22 +954,25 @@ export class LiveboardEmbed extends V1Embed {
     protected beforePrerenderVisible(): void {
         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<LiveboardEmbed>();
         const showing = previous === this ? undefined : 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.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);
                 });
@@ -987,8 +992,9 @@ export 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.
     private isShowingLiveboardRoute(showing?: LiveboardEmbed['currentLiveboardState']): boolean {
         if (!showing?.liveboardId) return false;
         const {

package/src/embed/search-bar.tsx

@@ -163,7 +163,7 @@ export class SearchBarEmbed extends TsEmbed {
      * @param dataSources A list of data source GUIDs
      */
     private getIFrameSrc() {
-        const queryParams = this.getEmbedParamsObject();
+        const queryParams = this.getUrlQueryParamsObject();
         const path = 'search-bar-embed';
        
         let query = '';

package/src/embed/search.spec.ts

@@ -854,6 +854,29 @@ test('should pass forceTable parameter when forceTable is true', async () => {
 });
 
 describe('SearchBarEmbed tests', () => {
+    test('should keep view config off the URL when excludeConfigFromURL is set', async () => {
+        const searchBarEmbed = new SearchBarEmbed(getRootEl() as any, {
+            ...defaultViewConfig,
+            dataSources: ['source-1', 'source-2'],
+            additionalFlags: { excludeConfigFromURL: true },
+        } as any);
+        searchBarEmbed.render();
+        await executeAfterWait(() => {
+            const iframeSrc = getIFrameSrc();
+
+            // Bootstrap params stay: the handshake, the embed marker that
+            // picks the app shell, and the data sources it boots against.
+            expect(iframeSrc).toContain('hostAppUrl=');
+            expect(iframeSrc).toContain('isSearchEmbed=true');
+            expect(iframeSrc).toContain('dataSources');
+
+            // The rest of the view config goes over
+            // HostEvent.UpdateEmbedParams.
+            expect(iframeSrc).not.toContain('hideAction');
+            expect(iframeSrc).not.toContain('useLastSelectedDataSource');
+        });
+    });
+
     test('should pass dataSources parameter when dataSources array is provided', async () => {
         const searchBarEmbed = new SearchBarEmbed(getRootEl() as any, {
             ...defaultViewConfig,

package/src/embed/search.ts

@@ -546,7 +546,7 @@ export class SearchEmbed extends TsEmbed {
             excludeRuntimeParametersfromURL,
             excludeRuntimeFiltersfromURL,
         } = this.viewConfig;
-        const queryParams = this.getEmbedParamsObject();
+        const queryParams = this.getUrlQueryParamsObject();
         let query = '';
         const queryParamsString = getQueryParamString(queryParams, true);
         if (queryParamsString) {

package/src/embed/spotter-utils.spec.ts

@@ -3,6 +3,7 @@ import {
     buildSpotterSidebarAppInitData,
     buildSpotterShareConversationAppInitData,
     buildStarterPromptsAppInitData,
+    buildSpotterAnalystAppInitData,
 } from './spotter-utils';
 import { ErrorDetailsTypes, EmbedErrorCodes } from '../types';
 import { ERROR_MESSAGE } from '../errors';
@@ -245,3 +246,31 @@ describe('buildStarterPromptsAppInitData', () => {
         expect(result.embedParams?.starterPrompts).toEqual({ enable: true, liveboard });
     });
 });
+
+describe('buildSpotterAnalystAppInitData', () => {
+    const base = { type: 'APP_INIT' } as any;
+
+    it('returns the payload unchanged when analystId is absent', () => {
+        expect(buildSpotterAnalystAppInitData(base, {})).toBe(base);
+        expect(buildSpotterAnalystAppInitData(base, { spotterAnalystConfig: {} })).toBe(base);
+    });
+
+    it('nests spotterAnalystConfig under embedParams', () => {
+        const result = buildSpotterAnalystAppInitData(base, {
+            spotterAnalystConfig: { analystId: 'analyst-id-1234' },
+        });
+        expect(result.embedParams?.spotterAnalystConfig).toEqual({ analystId: 'analyst-id-1234' });
+    });
+
+    it('preserves existing embedParams keys', () => {
+        const withExisting = {
+            ...base,
+            embedParams: { spotterSidebarConfig: { enablePastConversationsSidebar: true } },
+        } as any;
+        const result = buildSpotterAnalystAppInitData(withExisting, {
+            spotterAnalystConfig: { analystId: 'analyst-id-1234' },
+        });
+        expect(result.embedParams?.spotterSidebarConfig).toEqual({ enablePastConversationsSidebar: true });
+        expect(result.embedParams?.spotterAnalystConfig).toEqual({ analystId: 'analyst-id-1234' });
+    });
+});

package/src/embed/spotter-utils.ts

@@ -6,6 +6,7 @@ import type {
     SpotterShareConversationConfig,
     SpotterChatViewConfig,
     StarterPromptsConfig,
+    SpotterAnalystConfig,
 } from './conversation';
 import type { VisualizationOverrides } from '../types';
 
@@ -114,3 +115,18 @@ export function buildStarterPromptsAppInitData<T extends DefaultAppInitData>(
         },
     };
 }
+
+export function buildSpotterAnalystAppInitData<T extends DefaultAppInitData>(
+    initData: T,
+    viewConfig: { spotterAnalystConfig?: SpotterAnalystConfig },
+): T & { embedParams?: { spotterAnalystConfig?: SpotterAnalystConfig } } {
+    const { spotterAnalystConfig } = viewConfig;
+    if (!spotterAnalystConfig?.analystId) return initData;
+    return {
+        ...initData,
+        embedParams: {
+            ...((initData as T & { embedParams?: Record<string, unknown> }).embedParams || {}),
+            spotterAnalystConfig,
+        },
+    };
+}

package/src/embed/ts-embed.spec.ts

@@ -2964,8 +2964,8 @@ describe('Unit test case for ts embed', () => {
 
                 // Reverts to the exact value the container had before.
                 expect(customContainer.style.position).toBe('static');
-                // The custom container reference is dropped (back to the default
-                // body) so a destroyed embed does not pin the (possibly
+                // The custom container reference is dropped (back to the
+                // default body) so a destroyed embed does not pin the (possibly
                 // detached) element in memory.
                 expect((libEmbed as any).preRenderContainerEl).toBe(document.body);
 
@@ -3019,8 +3019,8 @@ describe('Unit test case for ts embed', () => {
 
                 libEmbed.destroy();
 
-                // The body sentinel must never be treated as a custom container:
-                // no position override to apply and none to restore.
+                // The body sentinel must never be treated as a custom
+                // container: no position override to apply and none to restore.
                 expect(document.body.style.position).toBe(originalBodyPosition);
                 expect(document.body.dataset.tsEmbedOriginalPosition).toBeUndefined();
             });
@@ -3155,10 +3155,11 @@ describe('Unit test case for ts embed', () => {
 
                 libEmbed.syncPreRenderStyle();
 
-                // applyPreRenderContainerPositioning() reads preRenderContainerEl
-                // instead of taking the container as an argument, so reconcile has
-                // to assign the field before calling it — otherwise the override
-                // lands on the detached node and the fresh one stays static.
+                // applyPreRenderContainerPositioning() reads
+                // preRenderContainerEl instead of taking the container as an
+                // argument, so reconcile has to assign the field before calling
+                // it — otherwise the override lands on the detached node and
+                // the fresh one stays static.
                 expect((libEmbed as any).preRenderContainerEl).toBe(newContainer);
                 expect(newContainer.style.position).toBe('relative');
                 expect(newContainer.dataset.tsEmbedOriginalPosition).toBe('static');
@@ -3289,7 +3290,8 @@ describe('Unit test case for ts embed', () => {
                     await firstEmbed.preRender();
                     await waitFor(() => !!getIFrameEl());
 
-                    // Reset position to static so the connecting embed also triggers the guard.
+                    // Reset position to static so the connecting embed also
+                    // triggers the guard.
                     customContainer.style.position = 'static';
                     delete customContainer.dataset['preRenderContainerOriginalPosition'];
 
@@ -3393,8 +3395,8 @@ describe('Unit test case for ts embed', () => {
                     await firstEmbed.preRender();
                     await waitFor(() => !!getIFrameEl());
 
-                    // Same config on both components — the value is redundant but
-                    // not wrong, so nagging about it would be noise.
+                    // Same config on both components — the value is redundant
+                    // but not wrong, so nagging about it would be noise.
                     const connectingEmbed = new LiveboardEmbed('#tsEmbedDiv', {
                         preRenderId: 'connect-same-element',
                         liveboardId: 'myLiveboardId',
@@ -3427,8 +3429,9 @@ describe('Unit test case for ts embed', () => {
                     await firstEmbed.preRender();
                     await waitFor(() => !!getIFrameEl());
 
-                    // A selector that resolves to the owner's element is the same
-                    // container, so the comparison must be by resolved node.
+                    // A selector that resolves to the owner's element is the
+                    // same container, so the comparison must be by resolved
+                    // node.
                     const connectingEmbed = new LiveboardEmbed('#tsEmbedDiv', {
                         preRenderId: 'connect-same-selector',
                         liveboardId: 'myLiveboardId',
@@ -3492,8 +3495,8 @@ describe('Unit test case for ts embed', () => {
                     await waitFor(() => !!getIFrameEl());
 
                     // Simulate a wrapper with no live embed behind it: the
-                    // __tsEmbed stamp used to locate the owner is gone, so there
-                    // is no container to inherit.
+                    // __tsEmbed stamp used to locate the owner is gone, so
+                    // there is no container to inherit.
                     const wrapper = document.getElementById(
                         firstEmbed.getPreRenderIds().wrapper,
                     );
@@ -5361,12 +5364,14 @@ describe('Trigger method edge cases', () => {
         const handleErrorSpy = jest.spyOn(searchEmbed as any, 'handleError').mockImplementation(() => {});
         await searchEmbed.render();
 
-        // First processTrigger call is getAvailableUIPassthroughKeys for DrillDown
+        // First processTrigger call is getAvailableUIPassthroughKeys for
+        // DrillDown
         mockProcessTrigger.mockResolvedValueOnce([
             { value: { keys: Object.values(UIPassthroughEvent) } },
         ]);
 
-        // DrillDown with no points → throwDrillDownValidationError → isValidationError=true
+        // DrillDown with no points → throwDrillDownValidationError →
+        // isValidationError=true
         await expect(
             searchEmbed.trigger(HostEvent.DrillDown, {} as any),
         ).rejects.toThrow('DrillDown requires a valid points object');
@@ -5541,7 +5546,8 @@ describe('Fullscreen change handler behavior', () => {
         init({
             thoughtSpotHost: 'tshost',
             authType: AuthType.None,
-            // disableFullscreenPresentation not set → defaults to true via ?? true
+            // disableFullscreenPresentation not set → defaults to true via ??
+            // true
         });
 
         const embed = new SearchEmbed(getRootEl(), defaultViewConfig);
@@ -5567,7 +5573,8 @@ describe('Fullscreen change handler behavior', () => {
 
         embed['setupFullscreenChangeHandler']();
 
-        // Capture the registered handler directly instead of dispatching to document
+        // Capture the registered handler directly instead of dispatching to
+        // document
         const fullscreenCall = addEventListenerSpy.mock.calls.find((c) => c[0] === 'fullscreenchange');
         expect(fullscreenCall).toBeTruthy();
         const handler = fullscreenCall[1] as EventListener;
@@ -6039,8 +6046,8 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
                 undefined,
             );
 
-            // A parameter always carries a value, so the payload says everything
-            // there is to say — no follow-up event.
+            // A parameter always carries a value, so the payload says
+            // everything there is to say — no follow-up event.
             const parameterCalls = mockProcessTrigger.mock.calls.filter(
                 (call: any[]) => call[1] === HostEvent.UpdateParameters,
             );
@@ -6641,7 +6648,8 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
             expect(hostElement.querySelector(`#${placeHolderId}`)).toBe(staleNestedPlaceholder);
             // Before the fix this threw NotFoundError.
             await expect(embed.showPreRender()).resolves.toBeDefined();
-            // The stale nested placeholder is gone; the fresh one is a direct child.
+            // The stale nested placeholder is gone; the fresh one is a direct
+            // child.
             expect(staleNestedPlaceholder.isConnected).toBe(false);
             const currentPlaceholder = (
                 embed as any
@@ -6673,7 +6681,8 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
                 { numberOfTabs: number; orderedTabIds: string[] }
             > = true;
             const probeUnknownField = (r: TabsResponse) =>
-                // @ts-expect-error — field not on the GetTabs contract (was silent when `any`)
+                // @ts-expect-error — field not on the GetTabs contract (was
+                // silent when `any`)
                 r.tabCount;
             void probeUnknownField;
 
@@ -6686,3 +6695,175 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
         });
     });
 });
+
+describe('excludeConfigFromURL', () => {
+    const lbConfig = {
+        liveboardId,
+        hiddenActions: [Action.Download],
+        additionalFlags: { internalBlinkFlag: true },
+        liveboardV2: true,
+    };
+
+    const withPostMessage = (viewConfig: any) => ({
+        ...viewConfig,
+        additionalFlags: { ...viewConfig.additionalFlags, excludeConfigFromURL: true },
+    });
+
+    const renderAndGetSrc = async (viewConfig: any) => {
+        const embed = new LiveboardEmbed(getRootEl(), { ...defaultViewConfig, ...viewConfig });
+        await embed.render();
+        await waitFor(() => !!getIFrameEl());
+        return { embed, src: getIFrameSrc() };
+    };
+
+    const signalFrameReady = () => {
+        postMessageToParent(getIFrameEl().contentWindow, {
+            type: EmbedEvent.EmbedListenerReady,
+        });
+    };
+
+    beforeEach(() => {
+        document.body.innerHTML = getDocumentBody();
+        mockProcessTrigger.mockReset();
+        mockProcessTrigger.mockResolvedValue({});
+        init({
+            thoughtSpotHost,
+            authType: AuthType.None,
+        });
+    });
+
+    test('leaves the URL untouched when the flag is not set', async () => {
+        const { src } = await renderAndGetSrc(lbConfig);
+
+        expect(src).toContain('hideAction=');
+        expect(src).toContain('internalBlinkFlag=true');
+        expect(src).toContain('isPinboardV2Enabled=true');
+    });
+
+    test('keeps only the bootstrap params on the URL when the flag is set', async () => {
+        const { src } = await renderAndGetSrc(withPostMessage(lbConfig));
+
+        // Boot and auth handshake stays on the URL.
+        expect(src).toContain('hostAppUrl=');
+        expect(src).toContain(`authType=${AuthType.None}`);
+        expect(src).toContain(`sdkVersion=${version}`);
+        expect(src).toContain('blockNonEmbedFullAppAccess=true');
+        expect(src).toContain('viewPortHeight=');
+
+        // View configuration and internal flags do not.
+        expect(src).not.toContain('hideAction=');
+        expect(src).not.toContain('internalBlinkFlag');
+        expect(src).not.toContain('isPinboardV2Enabled');
+        expect(src).not.toContain('enableDataPanelV2');
+    });
+
+    test('strips a non-bootstrap additionalFlag from the URL when the flag is set', async () => {
+        const { src } = await renderAndGetSrc({
+            ...lbConfig,
+            additionalFlags: {
+                internalBlinkFlag: true,
+                someCustomFlag: 'abc',
+                excludeConfigFromURL: true,
+            },
+        });
+
+        expect(src).not.toContain('internalBlinkFlag');
+        expect(src).not.toContain('someCustomFlag');
+    });
+
+    test('keeps an additionalFlag that overrides a bootstrap param on the URL', async () => {
+        const { src } = await renderAndGetSrc({
+            ...lbConfig,
+            additionalFlags: { [Param.OverrideOrgId]: 42, excludeConfigFromURL: true },
+        });
+
+        expect(src).toContain(`${Param.OverrideOrgId}=42`);
+    });
+
+    test('keeps the deep-link route on the URL when the flag is set', async () => {
+        const { src } = await renderAndGetSrc(withPostMessage(lbConfig));
+
+        expect(src).toContain(`/embed/viz/${liveboardId}`);
+    });
+
+    test('sends the full config over UpdateEmbedParams once the frame is ready', async () => {
+        await renderAndGetSrc(withPostMessage(lbConfig));
+
+        signalFrameReady();
+
+        await executeAfterWait(() => {
+            expect(mockProcessTrigger).toHaveBeenCalledWith(
+                expect.any(Object),
+                HostEvent.UpdateEmbedParams,
+                expect.any(String),
+                expect.objectContaining({
+                    liveboardId,
+                    hiddenActions: [Action.Download],
+                    internalBlinkFlag: true,
+                    [Param.HideActions]: expect.arrayContaining([Action.Download]),
+                }),
+                undefined,
+            );
+        });
+    });
+
+    test('sends UpdateEmbedParams again every time the frame signals ready', async () => {
+        await renderAndGetSrc(withPostMessage(lbConfig));
+        signalFrameReady();
+        signalFrameReady();
+
+        await executeAfterWait(() => {
+            const updateCalls = mockProcessTrigger.mock.calls.filter(
+                (call) => call[1] === HostEvent.UpdateEmbedParams,
+            );
+            expect(updateCalls).toHaveLength(2);
+        });
+    });
+
+    test('does not send UpdateEmbedParams when the flag is not set', async () => {
+        await renderAndGetSrc(lbConfig);
+
+        signalFrameReady();
+
+        await executeAfterWait(() => {
+            const updateCalls = mockProcessTrigger.mock.calls.filter(
+                (call) => call[1] === HostEvent.UpdateEmbedParams,
+            );
+            expect(updateCalls).toHaveLength(0);
+        });
+    });
+
+    test('does not double-send for a pre-rendered embed that is shown', async () => {
+        mockMessageChannel();
+        (window as any).ResizeObserver =
+            window.ResizeObserver ||
+            jest.fn().mockImplementation(() => ({
+                disconnect: jest.fn(),
+                observe: jest.fn(),
+                unobserve: jest.fn(),
+            }));
+
+        const embed = new LiveboardEmbed(getRootEl(), {
+            ...defaultViewConfig,
+            ...withPostMessage(lbConfig),
+            preRenderId: 'send-config-post-message',
+        });
+        await embed.preRender();
+        await waitFor(() => !!getIFrameEl());
+
+        signalFrameReady();
+        await executeAfterWait(() => {
+            expect(embed.isEmbedContainerLoaded).toBe(true);
+        });
+
+        mockProcessTrigger.mockClear();
+        await embed.showPreRender();
+
+        await executeAfterWait(() => {
+            const updateCalls = mockProcessTrigger.mock.calls.filter(
+                (call) => call[1] === HostEvent.UpdateEmbedParams,
+            );
+            expect(updateCalls).toHaveLength(1);
+        });
+    });
+});