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

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

@@ -2,7 +2,7 @@ import { resetValueFromWindow } from '../utils';
 import { ERROR_MESSAGE } from '../errors';
 import { resetCachedAuthToken } from '../authToken';
 import { AuthType, init, EmbedEvent, SearchEmbed, PinboardEmbed, AppEmbed, LiveboardEmbed, AnswerService, SpotterEmbed, } from '../index';
-import { Action, HomeLeftNavItem, RuntimeFilterOp, HomepageModule, HostEvent, ContextMenuTriggerOptions, CustomActionTarget, CustomActionsPosition, ErrorDetailsTypes, EmbedErrorCodes, EmbedErrorSeverity, } from '../types';
+import { Action, HomeLeftNavItem, RuntimeFilterOp, HomepageModule, HostEvent, Param, ContextMenuTriggerOptions, CustomActionTarget, CustomActionsPosition, ErrorDetailsTypes, EmbedErrorCodes, EmbedErrorSeverity, } from '../types';
 import { executeAfterWait, getDocumentBody, getIFrameEl, getIFrameSrc, getRootEl, postMessageToParent, defaultParamsForPinboardEmbed, waitFor, expectUrlMatchesWithParams, expectUrlToHaveParamsWithValues, mockMessageChannel, createRootEleForEmbed, fixedEncodeURI, } from '../test/test-utils';
 import * as config from '../config';
 import * as embedConfig from './embedConfig';
@@ -16,7 +16,7 @@ import { logger } from '../utils/logger';
 import { version } from '../../package.json';
 import { HiddenActionItemByDefaultForSearchEmbed } from './search';
 import { processTrigger } from '../utils/processTrigger';
-import { UIPassthroughEvent } from './hostEventClient/contracts';
+import { UIPassthroughEvent } from '../contracts/ui-passthrough-contracts';
 import * as sessionInfoService from '../utils/sessionInfoService';
 import * as authToken from '../authToken';
 import * as apiIntercept from '../api-intercept';
@@ -164,6 +164,9 @@ describe('Unit test case for ts embed', () => {
             liveboardEmbed.render();
             mockProcessTrigger.mockResolvedValue({ session: 'test' });
             await executeAfterWait(async () => {
+                // `false` is a deliberately off-contract payload here — this
+                // asserts raw passthrough to processTrigger, not a real Save
+                // payload — so it is cast past the typed `data` parameter.
                 await liveboardEmbed.trigger(HostEvent.Save, false);
                 expect(mockProcessTrigger).toHaveBeenCalledWith(getIFrameEl(), HostEvent.Save, 'http://tshost', false, undefined);
             });
@@ -2439,8 +2442,8 @@ describe('Unit test case for ts embed', () => {
                 libEmbed.destroy();
                 // 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.preRenderContainerEl).toBe(document.body);
                 customContainer.remove();
@@ -2481,8 +2484,8 @@ describe('Unit test case for ts embed', () => {
                 await libEmbed.preRender();
                 expect(libEmbed.preRenderContainerEl).toBe(document.body);
                 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();
             });
@@ -2593,10 +2596,11 @@ describe('Unit test case for ts embed', () => {
                 newContainer.style.position = 'static';
                 document.body.appendChild(newContainer);
                 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.preRenderContainerEl).toBe(newContainer);
                 expect(newContainer.style.position).toBe('relative');
                 expect(newContainer.dataset.tsEmbedOriginalPosition).toBe('static');
@@ -2701,7 +2705,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'];
                     const connectingEmbed = new LiveboardEmbed('#tsEmbedDiv', {
@@ -2782,8 +2787,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',
@@ -2809,8 +2814,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',
@@ -2860,8 +2866,8 @@ describe('Unit test case for ts embed', () => {
                     await firstEmbed.preRender();
                     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);
                     delete wrapper.__tsEmbed;
                     const connectingEmbed = new LiveboardEmbed('#tsEmbedDiv', {
@@ -3565,7 +3571,9 @@ describe('Unit test case for ts embed', () => {
         });
         test('should return getPreRenderObj and log if same object', () => {
             const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
-            const loggerSpy = jest.spyOn(logger, 'info');
+            // debug, not info: the wrapper points at the embed being shown, so
+            // this is now the common case rather than a rare diagnostic.
+            const loggerSpy = jest.spyOn(logger, 'debug');
             // getPreRenderObj reads the embed reference from preRenderWrapper
             searchEmbed.preRenderWrapper = {
                 [searchEmbed['embedNodeKey']]: searchEmbed,
@@ -4267,16 +4275,6 @@ describe('Additional Coverage Tests', () => {
             expect(getIFrameEl().style.height).toBe('500px');
         });
     });
-    test('should test getIframeCenter calculation', async () => {
-        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
-        await searchEmbed.render();
-        await executeAfterWait(() => {
-            const center = searchEmbed['getIframeCenter']();
-            expect(center).toHaveProperty('iframeCenter');
-            expect(center).toHaveProperty('iframeHeight');
-            expect(center).toHaveProperty('viewPortHeight');
-        });
-    });
     test('should handle preRender with replaceExistingPreRender=true', async () => {
         createRootEleForEmbed();
         const embed1 = new LiveboardEmbed('#tsEmbedDiv', {
@@ -4347,11 +4345,13 @@ describe('Trigger method edge cases', () => {
         const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
         const handleErrorSpy = jest.spyOn(searchEmbed, '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, {})).rejects.toThrow('DrillDown requires a valid points object');
         expect(handleErrorSpy).toHaveBeenCalledWith(expect.objectContaining({
             data: expect.objectContaining({ code: EmbedErrorCodes.HOST_EVENT_VALIDATION }),
@@ -4479,7 +4479,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);
         const addEventListenerSpy = jest.spyOn(document, 'addEventListener');
@@ -4497,7 +4498,8 @@ describe('Fullscreen change handler behavior', () => {
         const loggerDebugSpy = jest.spyOn(logger, 'debug').mockImplementation(() => { });
         const triggerSpy = jest.spyOn(embed, 'trigger').mockImplementation(() => Promise.resolve(null));
         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];
@@ -4576,7 +4578,8 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
         });
         embed2.showPreRender();
         await executeAfterWait(() => {
-            expect(mockProcessTrigger).toHaveBeenLastCalledWith(expect.any(Object), HostEvent.UpdateEmbedParams, expect.any(String), expect.objectContaining({
+            // Not LastCalledWith: LiveboardEmbed fires Navigate after this.
+            expect(mockProcessTrigger).toHaveBeenCalledWith(expect.any(Object), HostEvent.UpdateEmbedParams, expect.any(String), expect.objectContaining({
                 liveboardId: 'original-lb',
                 visibleVizs: ['viz-1'],
                 runtimeFilters: [
@@ -4619,7 +4622,8 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
         });
         embed2.showPreRender();
         await executeAfterWait(() => {
-            expect(mockProcessTrigger).toHaveBeenLastCalledWith(expect.any(Object), HostEvent.UpdateEmbedParams, expect.any(String), expect.objectContaining({
+            // Not LastCalledWith: LiveboardEmbed fires Navigate after this.
+            expect(mockProcessTrigger).toHaveBeenCalledWith(expect.any(Object), HostEvent.UpdateEmbedParams, expect.any(String), expect.objectContaining({
                 liveboardId: 'original-lb',
                 visibleVizs: ['viz-1', 'viz-2'],
                 runtimeFilters: [
@@ -4632,6 +4636,317 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
             }), undefined);
         });
     });
+    test('should carry the new config filters in UpdateEmbedParams', async () => {
+        await setupPreRenderTest('params-new-filters', { liveboardId: 'original-lb' });
+        const runtimeFilters = [
+            {
+                columnName: 'Color',
+                operator: RuntimeFilterOp.IN,
+                values: ['red', 'blue'],
+            },
+        ];
+        const embed2 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'params-new-filters',
+            liveboardId: 'original-lb',
+            runtimeFilters,
+        });
+        embed2.showPreRender();
+        await executeAfterWait(() => {
+            expect(mockProcessTrigger).toHaveBeenCalledWith(expect.any(Object), HostEvent.UpdateEmbedParams, expect.any(String), expect.objectContaining({
+                runtimeFilters,
+                // The serialized form is the one the container reads.
+                runtimeFilterParams: 'col1=Color&op1=IN&val1=red&val1=blue',
+            }), undefined);
+            // Everything rides in the params payload; nothing follows it.
+            const runtimeFilterCalls = mockProcessTrigger.mock.calls.filter((call) => call[1] === HostEvent.UpdateRuntimeFilters);
+            expect(runtimeFilterCalls).toHaveLength(0);
+        });
+    });
+    test('should serialize the filters when they are not excluded from the URL', async () => {
+        await setupPreRenderTest('params-url-filters', { liveboardId: 'original-lb' });
+        // With the flag off, getDefaultAppInitData leaves runtimeFilterParams
+        // null and a URL render carries the filters in the iframe's query
+        // string. A show cycle has no URL, so the payload has to carry them.
+        const embed2 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'params-url-filters',
+            liveboardId: 'original-lb',
+            excludeRuntimeFiltersfromURL: false,
+            runtimeFilters: [
+                {
+                    columnName: 'Color',
+                    operator: RuntimeFilterOp.IN,
+                    values: ['red'],
+                },
+            ],
+        });
+        embed2.showPreRender();
+        await executeAfterWait(() => {
+            expect(mockProcessTrigger).toHaveBeenCalledWith(expect.any(Object), HostEvent.UpdateEmbedParams, expect.any(String), expect.objectContaining({
+                runtimeFilterParams: 'col1=Color&op1=IN&val1=red',
+            }), undefined);
+        });
+    });
+    test('should trigger Navigate only after UpdateEmbedParams has settled', async () => {
+        await setupPreRenderTest('navigate-after-params', {
+            liveboardId: 'original-lb',
+            runtimeFilters: [
+                {
+                    columnName: 'Color',
+                    operator: RuntimeFilterOp.IN,
+                    values: ['red'],
+                },
+            ],
+        });
+        const embed2 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'navigate-after-params',
+            liveboardId: 'updated-lb',
+        });
+        embed2.showPreRender();
+        // Inside the settle window the params are already out
+        // and Navigate is not.
+        await executeAfterWait(() => {
+            const eventTypes = mockProcessTrigger.mock.calls.map((call) => call[1]);
+            expect(eventTypes).toContain(HostEvent.UpdateEmbedParams);
+            expect(eventTypes).not.toContain(HostEvent.Navigate);
+        }, 50);
+        await executeAfterWait(() => {
+            const eventTypes = mockProcessTrigger.mock.calls.map((call) => call[1]);
+            // A Navigate that beat the params would make the container load
+            // `updated-lb` while still holding `original-lb`'s runtime filters,
+            // and drop the params that then arrive mid-load (SCAL-336321).
+            expect(eventTypes).toContain(HostEvent.Navigate);
+            expect(eventTypes.indexOf(HostEvent.UpdateEmbedParams)).toBeLessThan(eventTypes.indexOf(HostEvent.Navigate));
+        }, 300);
+    });
+    test('should mark the params empty when the config declares no filters', async () => {
+        await setupPreRenderTest('params-clear-filters', {
+            liveboardId: 'original-lb',
+            runtimeFilters: [
+                {
+                    columnName: 'Color',
+                    operator: RuntimeFilterOp.IN,
+                    values: ['red', 'blue'],
+                },
+            ],
+        });
+        const embed2 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'params-clear-filters',
+            liveboardId: 'original-lb',
+        });
+        embed2.showPreRender();
+        await executeAfterWait(() => {
+            // Not null and not '': the container only reads this field when it
+            // is truthy, so either would leave the previous embed's filters in
+            // place. A lone separator passes that gate and parses to {}.
+            expect(mockProcessTrigger).toHaveBeenCalledWith(expect.any(Object), HostEvent.UpdateEmbedParams, expect.any(String), expect.objectContaining({ runtimeFilterParams: '&' }), undefined);
+            const runtimeFilterCalls = mockProcessTrigger.mock.calls.filter((call) => call[1] === HostEvent.UpdateRuntimeFilters);
+            expect(runtimeFilterCalls).toHaveLength(0);
+        });
+    });
+    test('should mark the params empty for an explicitly empty filter array', async () => {
+        await setupPreRenderTest('params-empty-array', {
+            liveboardId: 'original-lb',
+            runtimeFilters: [
+                {
+                    columnName: 'Color',
+                    operator: RuntimeFilterOp.IN,
+                    values: ['red'],
+                },
+            ],
+        });
+        // `runtimeFilters: []` is the shape the customer reported as not
+        // resetting anything.
+        const embed2 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'params-empty-array',
+            liveboardId: 'original-lb',
+            runtimeFilters: [],
+        });
+        embed2.showPreRender();
+        await executeAfterWait(() => {
+            expect(mockProcessTrigger).toHaveBeenCalledWith(expect.any(Object), HostEvent.UpdateEmbedParams, expect.any(String), expect.objectContaining({ runtimeFilterParams: '&' }), undefined);
+        });
+    });
+    test('should mark the params empty when no config in the chain has filters', async () => {
+        await setupPreRenderTest('params-no-filters', { liveboardId: 'original-lb' });
+        const embed2 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'params-no-filters',
+            liveboardId: 'updated-lb',
+        });
+        embed2.showPreRender();
+        await executeAfterWait(() => {
+            const paramsCall = mockProcessTrigger.mock.calls.find((call) => call[1] === HostEvent.UpdateEmbedParams);
+            expect(paramsCall === null || paramsCall === void 0 ? void 0 : paramsCall[3]).not.toHaveProperty('runtimeFilters');
+            expect(paramsCall === null || paramsCall === void 0 ? void 0 : paramsCall[3].runtimeFilterParams).toBe('&');
+        });
+    });
+    test('should state each embed filters as the pre-render is handed along', async () => {
+        await setupPreRenderTest('params-chain', {
+            liveboardId: 'original-lb',
+            runtimeFilters: [
+                {
+                    columnName: 'Color',
+                    operator: RuntimeFilterOp.IN,
+                    values: ['red', 'blue'],
+                },
+            ],
+        });
+        // Second in the chain declares none, so it empties the field rather
+        // than letting the creator's filters stand.
+        const embed2 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'params-chain',
+            liveboardId: 'second-lb',
+        });
+        await embed2.showPreRender();
+        await executeAfterWait(() => {
+            expect(mockProcessTrigger).toHaveBeenCalledWith(expect.any(Object), HostEvent.UpdateEmbedParams, expect.any(String), expect.objectContaining({ runtimeFilterParams: '&' }), undefined);
+        });
+        mockProcessTrigger.mockClear();
+        // Third declares its own, and states them without reference to either
+        // embed before it.
+        const embed3 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'params-chain',
+            liveboardId: 'third-lb',
+            runtimeFilters: [
+                {
+                    columnName: 'Region',
+                    operator: RuntimeFilterOp.EQ,
+                    values: ['North'],
+                },
+            ],
+        });
+        await embed3.showPreRender();
+        await executeAfterWait(() => {
+            expect(mockProcessTrigger).toHaveBeenCalledWith(expect.any(Object), HostEvent.UpdateEmbedParams, expect.any(String), expect.objectContaining({
+                runtimeFilterParams: 'col1=Region&op1=EQ&val1=North',
+            }), undefined);
+        });
+    });
+    test('should carry the new config runtime parameters in UpdateEmbedParams', async () => {
+        await setupPreRenderTest('params-parameters', {
+            liveboardId: 'original-lb',
+            runtimeParameters: [{ name: 'Region Param', value: 'East' }],
+        });
+        const runtimeParameters = [{ name: 'Region Param', value: 'West' }];
+        const embed2 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'params-parameters',
+            liveboardId: 'original-lb',
+            runtimeParameters,
+        });
+        embed2.showPreRender();
+        await executeAfterWait(() => {
+            expect(mockProcessTrigger).toHaveBeenCalledWith(expect.any(Object), HostEvent.UpdateEmbedParams, expect.any(String), expect.objectContaining({
+                runtimeParameters,
+                runtimeParameterParams: 'param1=Region%20Param&paramVal1=West',
+            }), undefined);
+            // 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) => call[1] === HostEvent.UpdateParameters);
+            expect(parameterCalls).toHaveLength(0);
+        });
+    });
+    test('should mark the params empty when the config declares no parameters', async () => {
+        await setupPreRenderTest('params-clear-parameters', {
+            liveboardId: 'original-lb',
+            runtimeParameters: [{ name: 'Region Param', value: 'East' }],
+        });
+        const embed2 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'params-clear-parameters',
+            liveboardId: 'original-lb',
+        });
+        embed2.showPreRender();
+        await executeAfterWait(() => {
+            // Same gate as the filters: the container only reads this field
+            // when it is truthy, so null would leave 'East' standing.
+            expect(mockProcessTrigger).toHaveBeenCalledWith(expect.any(Object), HostEvent.UpdateEmbedParams, expect.any(String), expect.objectContaining({ runtimeParameterParams: '&' }), undefined);
+        });
+    });
+    test('should keep an empty string parameter value distinct from having none', async () => {
+        await setupPreRenderTest('params-empty-value', { liveboardId: 'original-lb' });
+        // `paramVal1=` is that parameter's value, not an absence — so it must
+        // not collapse to the empty marker.
+        const embed2 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'params-empty-value',
+            liveboardId: 'original-lb',
+            runtimeParameters: [{ name: 'Region Param', value: '' }],
+        });
+        embed2.showPreRender();
+        await executeAfterWait(() => {
+            expect(mockProcessTrigger).toHaveBeenCalledWith(expect.any(Object), HostEvent.UpdateEmbedParams, expect.any(String), expect.objectContaining({
+                runtimeParameterParams: 'param1=Region%20Param&paramVal1=',
+            }), undefined);
+        });
+    });
+    test('should hand the pre-render over to the embed being shown', async () => {
+        const embed1 = await setupPreRenderTest('take-over-state', { liveboardId: 'original-lb' });
+        const embed2 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'take-over-state',
+            liveboardId: 'second-lb',
+        });
+        await embed2.showPreRender();
+        // It connected to embed1's pre-render and is now what the wrapper
+        // points at, so getPreRenderObj() means "what is showing".
+        expect(embed2.getPreRenderObj()).toBe(embed2);
+        expect(embed1.getPreRenderObj()).toBe(embed2);
+    });
+    test('should not strand callbacks when the container loads after the shown embed was hidden', async () => {
+        // The creator is subscribed but the container has NOT announced itself
+        // yet, which is the state a real pre-render starts in.
+        const embed1 = await setupPreRenderTest('loaded-after-hide', { liveboardId: 'original-lb' });
+        embed1.isEmbedContainerLoaded = false;
+        // Second embed shows, takes the pre-render over, then is hidden — which
+        // unsubscribes it, so it will never hear EmbedListenerReady itself.
+        const embed2 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'loaded-after-hide',
+            liveboardId: 'second-lb',
+        });
+        await embed2.showPreRender();
+        embed2.hidePreRender();
+        expect(embed2.isEmbedContainerLoaded).toBe(false);
+        // Container comes up and the creator hears it.
+        embed1.createEmbedContainerHandler(EmbedEvent.EmbedListenerReady)();
+        mockProcessTrigger.mockClear();
+        mockProcessTrigger.mockResolvedValue({});
+        // A third embed reads the state off embed2, which owns the wrapper and
+        // never learned the container was up. Reading a per-instance snapshot
+        // here leaves UpdateEmbedParams queued forever and the pre-render stuck
+        // on the previous liveboard.
+        const embed3 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'loaded-after-hide',
+            liveboardId: 'third-lb',
+        });
+        await embed3.showPreRender();
+        expect(embed3.isEmbedContainerLoaded).toBe(true);
+        await executeAfterWait(() => {
+            const eventTypes = mockProcessTrigger.mock.calls.map((call) => call[1]);
+            expect(eventTypes).toContain(HostEvent.UpdateEmbedParams);
+        }, 300);
+    });
+    test('should not reconcile runtime filters unless the view config opts in', async () => {
+        await setupPreRenderTest('reconcile-flag-off', {
+            liveboardId: 'original-lb',
+            runtimeFilters: [
+                {
+                    columnName: 'Color',
+                    operator: RuntimeFilterOp.IN,
+                    values: ['red', 'blue'],
+                },
+            ],
+        });
+        // Same shape as the clear-filters case above, minus the flag: the
+        // previous config left filters on the shared pre-render and this one
+        // declares none. Without preRenderConfig.reconcileRuntimeParams the SDK
+        // leaves that to the container, so no UpdateRuntimeFilters goes out.
+        const embed2 = new LiveboardEmbed('#tsEmbedDiv', {
+            preRenderId: 'reconcile-flag-off',
+            liveboardId: 'original-lb',
+        });
+        embed2.showPreRender();
+        await executeAfterWait(() => {
+            const eventTypes = mockProcessTrigger.mock.calls.map((call) => call[1]);
+            expect(eventTypes).toContain(HostEvent.UpdateEmbedParams);
+            expect(eventTypes).not.toContain(HostEvent.UpdateRuntimeFilters);
+        });
+    });
     test('should handle error when getUpdateEmbedParamsObject fails during showPreRender', async () => {
         await setupPreRenderTest('error-test', { liveboardId: 'original-lb' });
         const handleErrorSpy = jest.spyOn(LiveboardEmbed.prototype, 'handleError');
@@ -4991,7 +5306,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.getPreRenderPlaceHolderElement();
             expect(currentPlaceholder.parentElement).toBe(hostElement);
@@ -5005,7 +5321,8 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
             const tabsIsTyped = false;
             const tabsHasContractFields = true;
             const probeUnknownField = (r) => 
-            // @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;
             const reload = () => searchEmbed.trigger(HostEvent.Reload);
@@ -5015,4 +5332,135 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
         });
     });
 });
+describe('excludeConfigFromURL', () => {
+    const lbConfig = {
+        liveboardId,
+        hiddenActions: [Action.Download],
+        additionalFlags: { internalBlinkFlag: true },
+        liveboardV2: true,
+    };
+    const withPostMessage = (viewConfig) => ({
+        ...viewConfig,
+        additionalFlags: { ...viewConfig.additionalFlags, excludeConfigFromURL: true },
+    });
+    const renderAndGetSrc = async (viewConfig) => {
+        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.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);
+        });
+    });
+});
 //# sourceMappingURL=ts-embed.spec.js.map