@thoughtspot/visual-embed-sdk 1.50.0 → 1.50.1

package/src/embed/hostEventClient/utils.spec.ts

@@ -1,8 +1,10 @@
 import {
     isValidUpdateFiltersPayload,
+    isValidUpdateParametersPayload,
     isValidDrillDownPayload,
     createValidationError,
     throwUpdateFiltersValidationError,
+    throwUpdateParametersValidationError,
     throwDrillDownValidationError,
 } from './utils';
 import { ERROR_MESSAGE } from '../../errors';
@@ -114,6 +116,201 @@ describe('hostEventClient utils', () => {
                 filters: [{ column: 'y' }], // invalid
             } as any)).toBe(true);
         });
+
+        it('returns true for filter without applicability', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: { column: 'x', oper: 'EQ', values: ['a'] },
+            } as any)).toBe(true);
+        });
+
+        it('returns true for filter with valid applicability', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: {
+                    column: 'x',
+                    oper: 'EQ',
+                    values: ['a'],
+                    applicability: { level: 'TAB', targetId: 'tab-guid-1' },
+                },
+            } as any)).toBe(true);
+        });
+
+        it('returns true for filters array with applicability on some filters', () => {
+            expect(isValidUpdateFiltersPayload({
+                filters: [
+                    {
+                        column: 'x',
+                        oper: 'IN',
+                        values: ['a', 'b'],
+                        applicability: { level: 'TAB', targetId: 'tab-guid-1' },
+                    },
+                    { column: 'y', oper: 'EQ', values: ['c'] },
+                ],
+            } as any)).toBe(true);
+        });
+
+        it('returns false for applicability missing targetId', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: {
+                    column: 'x',
+                    oper: 'EQ',
+                    values: ['a'],
+                    applicability: { level: 'TAB' },
+                },
+            } as any)).toBe(false);
+        });
+
+        it('returns false for applicability with empty targetId', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: {
+                    column: 'x',
+                    oper: 'EQ',
+                    values: ['a'],
+                    applicability: { level: 'TAB', targetId: '' },
+                },
+            } as any)).toBe(false);
+        });
+
+        it('returns false for null applicability', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: {
+                    column: 'x',
+                    oper: 'EQ',
+                    values: ['a'],
+                    applicability: null,
+                },
+            } as any)).toBe(false);
+        });
+
+        it('returns false for non-object applicability', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: {
+                    column: 'x',
+                    oper: 'EQ',
+                    values: ['a'],
+                    applicability: 'TAB',
+                },
+            } as any)).toBe(false);
+        });
+
+        it('returns true for LIVEBOARD level applicability without targetId', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: {
+                    column: 'x',
+                    oper: 'EQ',
+                    values: ['a'],
+                    applicability: { level: 'LIVEBOARD' },
+                },
+            } as any)).toBe(true);
+        });
+
+        it('returns false for applicability missing level', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: {
+                    column: 'x',
+                    oper: 'EQ',
+                    values: ['a'],
+                    applicability: { targetId: 'tab-guid-1' },
+                },
+            } as any)).toBe(false);
+        });
+
+        it('returns false for applicability with non-string level', () => {
+            expect(isValidUpdateFiltersPayload({
+                filter: {
+                    column: 'x',
+                    oper: 'EQ',
+                    values: ['a'],
+                    applicability: { level: 123, targetId: 'tab-guid-1' },
+                },
+            } as any)).toBe(false);
+        });
+
+        it('returns false if one filter in filters array has invalid applicability', () => {
+            expect(isValidUpdateFiltersPayload({
+                filters: [
+                    { column: 'x', oper: 'EQ', values: ['a'] },
+                    {
+                        column: 'y',
+                        oper: 'EQ',
+                        values: ['b'],
+                        applicability: { level: 'TAB' }, // missing targetId
+                    },
+                ],
+            } as any)).toBe(false);
+        });
+    });
+
+    // =========================
+    // UpdateParameters Validation
+    // =========================
+    describe('isValidUpdateParametersPayload', () => {
+        it('returns true for undefined payload', () => {
+            expect(isValidUpdateParametersPayload(undefined)).toBe(true);
+        });
+
+        it('returns true for non-array payload', () => {
+            expect(isValidUpdateParametersPayload({ name: 'p', value: 1 })).toBe(true);
+        });
+
+        it('returns true for parameters without applicability', () => {
+            expect(isValidUpdateParametersPayload([
+                { name: 'p1', value: 1 },
+                { name: 'p2', value: 'a' },
+            ])).toBe(true);
+        });
+
+        it('returns true for null applicability', () => {
+            expect(isValidUpdateParametersPayload([
+                { name: 'p', value: 1, applicability: null },
+            ])).toBe(true);
+        });
+
+        it('returns true for valid TAB applicability with targetId', () => {
+            expect(isValidUpdateParametersPayload([
+                { name: 'p', value: 1, applicability: { level: 'TAB', targetId: 'tab-guid-1' } },
+            ])).toBe(true);
+        });
+
+        it('returns true for LIVEBOARD level applicability without targetId', () => {
+            expect(isValidUpdateParametersPayload([
+                { name: 'p', value: 1, applicability: { level: 'LIVEBOARD' } },
+            ])).toBe(true);
+        });
+
+        it('returns false for applicability missing targetId', () => {
+            expect(isValidUpdateParametersPayload([
+                { name: 'p', value: 1, applicability: { level: 'TAB' } },
+            ])).toBe(false);
+        });
+
+        it('returns false for applicability with empty targetId', () => {
+            expect(isValidUpdateParametersPayload([
+                { name: 'p', value: 1, applicability: { level: 'GROUP', targetId: ' ' } },
+            ])).toBe(false);
+        });
+
+        it('returns false for applicability with invalid level', () => {
+            expect(isValidUpdateParametersPayload([
+                { name: 'p', value: 1, applicability: { level: 'VIZ', targetId: 'guid-1' } },
+            ])).toBe(false);
+        });
+
+        it('returns false for non-object applicability', () => {
+            expect(isValidUpdateParametersPayload([
+                { name: 'p', value: 1, applicability: 'TAB' },
+            ])).toBe(false);
+        });
+
+        it('returns false if one parameter has invalid applicability', () => {
+            expect(isValidUpdateParametersPayload([
+                { name: 'p1', value: 1 },
+                { name: 'p2', value: 2, applicability: { level: 'GROUP' } }, // missing targetId
+            ])).toBe(false);
+        });
+
+        it('returns true for non-object entries', () => {
+            expect(isValidUpdateParametersPayload(['p', 1, null])).toBe(true);
+        });
     });
 
     // =========================
@@ -216,6 +413,13 @@ describe('hostEventClient utils', () => {
         });
     });
 
+    describe('throwUpdateParametersValidationError', () => {
+        it('throws with UPDATEPARAMETERS_INVALID_PAYLOAD message', () => {
+            expect(() => throwUpdateParametersValidationError())
+                .toThrow(ERROR_MESSAGE.UPDATEPARAMETERS_INVALID_PAYLOAD);
+        });
+    });
+
     describe('throwDrillDownValidationError', () => {
         it('throws with DRILLDOWN_INVALID_PAYLOAD message', () => {
             expect(() => throwDrillDownValidationError())

package/src/embed/hostEventClient/utils.ts

@@ -1,27 +1,40 @@
+import isNil from 'lodash/isNil';
+import isPlainObject from 'lodash/isPlainObject';
+import isString from 'lodash/isString';
+import isUndefined from 'lodash/isUndefined';
 import { EmbedErrorCodes, EmbedEvent, ErrorDetailsTypes, HostEvent } from '../../types';
 import { ERROR_MESSAGE } from '../../errors';
-import { HostEventRequest } from './contracts';
+import { ApplicabilityLevel, HostEventRequest } from './contracts';
 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
+  return isPlainObject(a)
+      && Object.values(ApplicabilityLevel).includes(a.level as ApplicabilityLevel)
+      && (a.level === ApplicabilityLevel.Liveboard || (isString(a.targetId) && a.targetId.trim().length > 0));
+};
+
 export function isValidUpdateFiltersPayload(
   payload: HostEventRequest<HostEvent.UpdateFilters> | undefined,
 ): boolean {
   if (!payload) return false;
 
-  const isValidFilter = (f: { 
-    column?: string; 
-    oper?: string; 
-    values?: unknown[]; 
-    type?: string; 
-    columnName?: string; 
-    operator?: string 
+  const isValidFilter = (f: {
+    column?: string;
+    oper?: string;
+    values?: unknown[];
+    type?: string;
+    columnName?: string;
+    operator?: string;
+    applicability?: { level?: string; targetId?: string };
   }) => {
     const hasColumn = typeof f.column === 'string' || typeof f.columnName === 'string';
     const hasOperator = typeof f.oper === 'string' || typeof f.operator === 'string';
     const hasValues = Array.isArray(f.values);
     const validType = !f.type || typeof f.type === 'string';
-  
-    return hasColumn && hasOperator && hasValues && validType;
+
+    return hasColumn && hasOperator && hasValues && validType && isValidApplicability(f.applicability);
   };
 
   const hasValidFilter = payload.filter && isValidFilter(payload.filter);
@@ -30,6 +43,16 @@ export function isValidUpdateFiltersPayload(
   return !!(hasValidFilter || hasValidFilters);
 }
 
+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.
+  if (!Array.isArray(payload)) return true;
+  return payload.every((p) => {
+      if (!isPlainObject(p)) return true;
+      const { applicability } = p as { applicability?: { level?: string; targetId?: string } };
+      return isNil(applicability) || isValidApplicability(applicability);
+  });
+}
+
 export function isValidDrillDownPayload(
   payload: HostEventRequest<HostEvent.DrillDown> | undefined,
 ): boolean {
@@ -72,3 +95,7 @@ export function throwUpdateFiltersValidationError(): never {
 export function throwDrillDownValidationError(): never {
   createValidationError(ERROR_MESSAGE.DRILLDOWN_INVALID_PAYLOAD);
 }
+
+export function throwUpdateParametersValidationError(): never {
+  createValidationError(ERROR_MESSAGE.UPDATEPARAMETERS_INVALID_PAYLOAD);
+}

package/src/embed/liveboard.ts

@@ -580,6 +580,12 @@ export interface LiveboardViewConfig extends BaseViewConfig, LiveboardOtherViewC
      *            { label: 'Tip', text: 'try asking about revenue by region' },
      *            { label: 'Tip', text: 'use natural language' },
      *        ],
+     *        // liveboardBrandName, spotterBrandName, insightTileBrandName, insightTileViewPlanLabel and insightTileLoaderText require SDK: 1.52.0 | ThoughtSpot Cloud: 26.9.0.cl
+     *        liveboardBrandName: 'Reports',
+     *        spotterBrandName: 'Analyst',
+     *        insightTileBrandName: 'Insight card',
+     *        insightTileViewPlanLabel: 'View plan',
+     *        insightTileLoaderText: 'Generating insight',
      *    },
      * })
      * ```

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

@@ -20,6 +20,23 @@ describe('buildSpotterVizAppInitData', () => {
         expect(result.embedParams?.spotterVizConfig?.brandHeadline).toBe("Hi, there! I'm");
     });
 
+    it('passes liveboardBrandName, spotterBrandName, insightTileBrandName, insightTileViewPlanLabel and insightTileLoaderText through spotterVizConfig', () => {
+        const spotterViz = {
+            brandName: 'MyBrand',
+            liveboardBrandName: 'Reports',
+            spotterBrandName: 'Analyst',
+            insightTileBrandName: 'Insight card',
+            insightTileViewPlanLabel: 'View plan',
+            insightTileLoaderText: 'Generating insight',
+        };
+        const result = buildSpotterVizAppInitData(base, { spotterViz });
+        expect(result.embedParams?.spotterVizConfig?.liveboardBrandName).toBe('Reports');
+        expect(result.embedParams?.spotterVizConfig?.spotterBrandName).toBe('Analyst');
+        expect(result.embedParams?.spotterVizConfig?.insightTileBrandName).toBe('Insight card');
+        expect(result.embedParams?.spotterVizConfig?.insightTileViewPlanLabel).toBe('View plan');
+        expect(result.embedParams?.spotterVizConfig?.insightTileLoaderText).toBe('Generating insight');
+    });
+
     it('preserves existing embedParams when adding spotterVizConfig', () => {
         const existing = { ...base, embedParams: { spotterSidebarConfig: { enablePastConversationsSidebar: true } } };
         const spotterViz = { brandName: 'MyBrand' };

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

@@ -38,6 +38,12 @@ export interface SpotterVizStarterPrompt {
  *            { label: 'Tip', text: 'try asking about revenue by region' },
  *            { label: 'Tip', text: 'use natural language' },
  *        ],
+ *        // liveboardBrandName, spotterBrandName, insightTileBrandName, insightTileViewPlanLabel and insightTileLoaderText require SDK: 1.52.0 | ThoughtSpot Cloud: 26.9.0.cl
+ *        liveboardBrandName: 'Reports',
+ *        spotterBrandName: 'Analyst',
+ *        insightTileBrandName: 'Insight card',
+ *        insightTileViewPlanLabel: 'View plan',
+ *        insightTileLoaderText: 'Generating insight',
  *    },
  * })
  * ```
@@ -94,6 +100,34 @@ export interface SpotterVizConfig {
      * @version SDK: 1.51.0 | ThoughtSpot Cloud: 26.8.0.cl
      */
     loaderTips?: SpotterVizLoaderTip[];
+    /**
+     * Custom term used to replace "Liveboard" in the agent's responses.
+     * @version SDK: 1.52.0 | ThoughtSpot Cloud: 26.9.0.cl
+     * @default ''
+     */
+    liveboardBrandName?: string;
+    /**
+     * Custom term used to replace "Spotter" in the agent's responses.
+     * @version SDK: 1.52.0 | ThoughtSpot Cloud: 26.9.0.cl
+     * @default ''
+     */
+    spotterBrandName?: string;
+    /**
+     * Custom term used to replace "Insight tile" in the UI and in the agent's responses.
+     * @version SDK: 1.52.0 | ThoughtSpot Cloud: 26.9.0.cl
+     * @default ''
+     */
+    insightTileBrandName?: string;
+    /**
+     * Custom term used to replace "View plan" in the insight tile menu.
+     * @version SDK: 1.52.0 | ThoughtSpot Cloud: 26.9.0.cl
+     */
+    insightTileViewPlanLabel?: string;
+    /**
+     * Custom loader text shown on the insight tile.
+     * @version SDK: 1.52.0 | ThoughtSpot Cloud: 26.9.0.cl
+     */
+    insightTileLoaderText?: string;
 }
 
 /**

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

@@ -1409,6 +1409,40 @@ describe('Unit test case for ts embed', () => {
             const { mockGetPreauthInfo } = await setup(true, 123);
             expect(mockGetPreauthInfo).toHaveBeenCalledTimes(0);
         });
+
+        test('should NOT trigger InfoSuccess when getPreauthInfo resolves with no .info field', async () => {
+            jest.spyOn(window, 'addEventListener').mockImplementationOnce(
+                (event, handler) => {
+                    (handler as EventListener)({
+                        data: { type: 'xyz' },
+                        ports: [3000],
+                        source: null,
+                    } as any);
+                },
+            );
+            mockProcessTrigger.mockResolvedValueOnce({ session: 'test' });
+            jest.spyOn(authService, 'fetchPreauthInfoService').mockResolvedValueOnce({
+                ok: true,
+                headers: new Headers({ 'content-type': 'application/json' }),
+                json: async () => ({}), // no .info field
+            } as any);
+            const iFrame: any = document.createElement('div');
+            jest.spyOn(baseInstance, 'getAuthPromise').mockResolvedValueOnce(true as any);
+            const tsEmbed = new SearchEmbed(getRootEl(), {});
+            iFrame.contentWindow = { postMessage: jest.fn() };
+            jest.spyOn(iFrame, 'addEventListener').mockImplementationOnce(
+                (event, handler) => { (handler as EventListener)({} as Event); },
+            );
+            jest.spyOn(document, 'createElement').mockReturnValueOnce(iFrame);
+            await tsEmbed.render();
+
+            await executeAfterWait(() => {
+                const infoSuccessCall = mockProcessTrigger.mock.calls.find(
+                    (call) => call[1] === HostEvent.InfoSuccess,
+                );
+                expect(infoSuccessCall).toBeUndefined();
+            });
+        });
     });
 
     describe('Preauth Cache for FullAppEmbed with PrimaryNavBar', () => {
@@ -2281,6 +2315,46 @@ describe('Unit test case for ts embed', () => {
             });
         });
 
+        it('Sets the overrideHistoryState param', async () => {
+            const appEmbed = new AppEmbed(getRootEl(), {
+                frameParams: {
+                    width: '100%',
+                    height: '100%',
+                },
+                overrideHistoryState: true,
+            });
+            await appEmbed.render();
+            expectUrlToHaveParamsWithValues(getIFrameSrc(), {
+                overrideHistoryState: true,
+            });
+        });
+
+        it('Sets the overrideHistoryState param to false', async () => {
+            const appEmbed = new AppEmbed(getRootEl(), {
+                frameParams: {
+                    width: '100%',
+                    height: '100%',
+                },
+                overrideHistoryState: false,
+            });
+            await appEmbed.render();
+            expectUrlToHaveParamsWithValues(getIFrameSrc(), {
+                overrideHistoryState: false,
+            });
+        });
+
+        it('Should not add overrideHistoryState param when it is undefined', async () => {
+            const appEmbed = new AppEmbed(getRootEl(), {
+                frameParams: {
+                    width: '100%',
+                    height: '100%',
+                },
+            });
+            await appEmbed.render();
+            const url = getIFrameSrc();
+            expect(url).not.toContain('overrideHistoryState');
+        });
+
         it('Should not add contextMenuEnabledOnWhichClick flag to the iframe src when it is not passed', async () => {
             const liveboardEmbed = new LiveboardEmbed(getRootEl(), {
                 ...defaultViewConfig,
@@ -4570,6 +4644,28 @@ describe('Trigger method edge cases', () => {
             expect(result).toBeNull();
         });
     });
+
+    test('isValidationError catch: handleError called with embedErrorDetails and error is rethrown', async () => {
+        const searchEmbed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        const handleErrorSpy = jest.spyOn(searchEmbed as any, 'handleError').mockImplementation(() => {});
+        await searchEmbed.render();
+
+        // First processTrigger call is getAvailableUIPassthroughKeys for DrillDown
+        mockProcessTrigger.mockResolvedValueOnce([
+            { value: { keys: Object.values(UIPassthroughEvent) } },
+        ]);
+
+        // DrillDown with no points → throwDrillDownValidationError → isValidationError=true
+        await expect(
+            searchEmbed.trigger(HostEvent.DrillDown, {} as any),
+        ).rejects.toThrow('DrillDown requires a valid points object');
+
+        expect(handleErrorSpy).toHaveBeenCalledWith(
+            expect.objectContaining({
+                data: expect.objectContaining({ code: EmbedErrorCodes.HOST_EVENT_VALIDATION }),
+            }),
+        );
+    });
 });
 
 describe('PreRender replaceExistingPreRender scenarios', () => {
@@ -4580,6 +4676,10 @@ describe('PreRender replaceExistingPreRender scenarios', () => {
         });
     });
 
+    beforeEach(() => {
+        document.body.innerHTML = getDocumentBody();
+    });
+
     afterEach(() => {
         const rootEle = document.getElementById('myRoot');
         rootEle?.remove();
@@ -4725,6 +4825,52 @@ describe('Fullscreen change handler behavior', () => {
             );
         });
     });
+
+    test('disableFullscreenPresentation undefined defaults to true — no fullscreenchange listener registered', () => {
+        init({
+            thoughtSpotHost: 'tshost',
+            authType: AuthType.None,
+            // disableFullscreenPresentation not set → defaults to true via ?? true
+        });
+
+        const embed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        const addEventListenerSpy = jest.spyOn(document, 'addEventListener');
+
+        embed['setupFullscreenChangeHandler']();
+
+        expect(addEventListenerSpy).not.toHaveBeenCalledWith('fullscreenchange', expect.any(Function));
+
+        addEventListenerSpy.mockRestore();
+        // Restore for other tests in this describe
+        init({ thoughtSpotHost: 'tshost', authType: AuthType.None, disableFullscreenPresentation: false });
+    });
+
+    test('fullscreenchange fires but iFrame.contentWindow is null — trigger NOT called, debug log emitted', () => {
+        const embed = new SearchEmbed(getRootEl(), defaultViewConfig);
+        // Give the embed a fake iFrame with null contentWindow
+        (embed as any).iFrame = { contentWindow: null };
+
+        const addEventListenerSpy = jest.spyOn(document, 'addEventListener');
+        const loggerDebugSpy = jest.spyOn(logger, 'debug').mockImplementation(() => {});
+        const triggerSpy = jest.spyOn(embed, 'trigger' as any).mockImplementation(() => Promise.resolve(null));
+
+        embed['setupFullscreenChangeHandler']();
+
+        // 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;
+
+        Object.defineProperty(document, 'fullscreenElement', { value: null, writable: true, configurable: true });
+        handler(new Event('fullscreenchange'));
+
+        expect(triggerSpy).not.toHaveBeenCalled();
+        expect(loggerDebugSpy).toHaveBeenCalledWith(expect.stringContaining('Skipping ExitPresentMode'));
+
+        addEventListenerSpy.mockRestore();
+        loggerDebugSpy.mockRestore();
+        triggerSpy.mockRestore();
+    });
 });
 
 describe('ShowPreRender with UpdateEmbedParams', () => {
@@ -5315,5 +5461,45 @@ describe('ShowPreRender with UpdateEmbedParams', () => {
 
             embed.destroy();
         });
+
+        // showPreRender located the stale placeholder with a subtree-wide
+        // querySelector but removed it with hostElement.removeChild(), which
+        // only accepts direct children. With fullHeight the placeholder can be
+        // nested deeper than a direct child, so removeChild threw
+        // "NotFoundError: Failed to execute 'removeChild' on 'Node'".
+        it('showPreRender removes a placeholder nested below a direct child without throwing', async () => {
+            createRootEleForEmbed();
+            const embed = new LiveboardEmbed('#tsEmbedDiv', {
+                preRenderId: 'ph-nested-test',
+                liveboardId: 'lb-id',
+                fullHeight: true,
+            } as any);
+            await embed.preRender();
+            await waitFor(
+                () => !!document.querySelector('#tsEmbed-pre-render-child-ph-nested-test'),
+            );
+
+            const hostElement = document.querySelector('#tsEmbedDiv') as HTMLElement;
+            const placeHolderId = 'tsEmbed-pre-render-placeholder-ph-nested-test';
+            // Simulate the fullHeight layout where the placeholder ends up as
+            // a grandchild of the host element rather than a direct child.
+            const intermediateWrapper = document.createElement('div');
+            const staleNestedPlaceholder = document.createElement('div');
+            staleNestedPlaceholder.id = placeHolderId;
+            intermediateWrapper.appendChild(staleNestedPlaceholder);
+            hostElement.appendChild(intermediateWrapper);
+
+            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.
+            expect(staleNestedPlaceholder.isConnected).toBe(false);
+            const currentPlaceholder = (
+                embed as any
+            ).getPreRenderPlaceHolderElement() as HTMLDivElement;
+            expect(currentPlaceholder.parentElement).toBe(hostElement);
+
+            embed.destroy();
+        });
     });
 });

package/src/embed/ts-embed.ts

@@ -771,6 +771,7 @@ export class TsEmbed {
             insertInToSlide,
             disableRedirectionLinksInNewTab,
             overrideOrgId,
+            overrideHistoryState,
             exposeTranslationIDs,
             primaryAction,
         } = this.viewConfig;
@@ -869,6 +870,9 @@ export class TsEmbed {
         if (overrideOrgId !== undefined) {
             queryParams[Param.OverrideOrgId] = overrideOrgId;
         }
+        if (overrideHistoryState !== undefined) {
+            queryParams[Param.OverrideHistoryState] = overrideHistoryState;
+        }
 
         if (this.isPreAuthCacheEnabled()) {
             queryParams[Param.preAuthCache] = true;
@@ -1999,10 +2003,14 @@ export class TsEmbed {
             }
 
             const placeHolderId = this.getPreRenderIds().placeHolder;
-            const oldEle = this.hostElement.querySelector(`#${placeHolderId}`);
-            if (oldEle) {
-                this.hostElement.removeChild(oldEle);
-            }
+            // 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().
+            this.hostElement.querySelector(`#${placeHolderId}`)?.remove();
 
             this.hostElement.appendChild(this.insertedDomEl);
 

package/src/errors.ts

@@ -31,6 +31,7 @@ export const ERROR_MESSAGE = {
     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 }, ...] }',
     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',
 };
 
 export const CUSTOM_ACTIONS_ERROR_MESSAGE = {

package/src/index.ts

@@ -32,7 +32,7 @@ import { PinboardEmbed, LiveboardViewConfig, LiveboardEmbed } from './embed/live
 import { SearchEmbed, SearchViewConfig } from './embed/search';
 import { SearchBarEmbed, SearchBarViewConfig } from './embed/search-bar';
 import { SpotterAgentEmbed, SpotterAgentEmbedViewConfig, BodylessConversation, BodylessConversationViewConfig} from './embed/bodyless-conversation';
-import { SpotterEmbed, SpotterEmbedViewConfig, SpotterChatViewConfig, SpotterSidebarViewConfig, ConversationEmbed, ConversationViewConfig } from './embed/conversation';
+import { SpotterEmbed, SpotterEmbedViewConfig, SpotterChatViewConfig, SpotterSidebarViewConfig, SpotterQueryMode, ConversationEmbed, ConversationViewConfig } from './embed/conversation';
 import { SpotterVizConfig, SpotterVizStarterPrompt, SpotterVizLoaderTip } from './embed/spotter-viz-utils';
 import {
     AuthFailureType, AuthStatus, AuthEvent, AuthEventEmitter,
@@ -117,6 +117,7 @@ export {
     SpotterEmbedViewConfig,
     SpotterChatViewConfig,
     SpotterSidebarViewConfig,
+    SpotterQueryMode,
     ConversationViewConfig,
     ConversationEmbed,
     AuthFailureType,