@thoughtspot/visual-embed-sdk 1.50.0 → 1.51.0

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

@@ -7,6 +7,7 @@ import {
     init,
     AuthType,
     LiveboardEmbed,
+    AppEmbed,
     HostEvent,
     EmbedErrorCodes,
 } from '../index';
@@ -148,6 +149,37 @@ describe('HostEvent.OpenFilter', () => {
     });
 });
 
+// ---------------------------------------------------------------------------
+// 10b – OpenParameter
+// ---------------------------------------------------------------------------
+describe('HostEvent.OpenParameter', () => {
+    test('postMessage type is openParameter (camelCase)', async () => {
+        mockMessageChannel();
+        const { lb, iframe } = await renderLiveboard();
+        await executeAfterWait(() => {
+            lb.trigger(HostEvent.OpenParameter, { parameter: { parameterId: 'p1' } } as any);
+            expect(iframe.contentWindow.postMessage).toHaveBeenCalledWith(
+                expect.objectContaining({ type: 'openParameter' }),
+                thoughtSpotHost,
+                expect.anything(),
+            );
+        });
+    });
+
+    test('accepts a payload with only parameterName', async () => {
+        mockMessageChannel();
+        const { lb, iframe } = await renderLiveboard();
+        await executeAfterWait(() => {
+            lb.trigger(HostEvent.OpenParameter, { parameter: { parameterName: 'Param 1' } } as any);
+            expect(iframe.contentWindow.postMessage).toHaveBeenCalledWith(
+                expect.objectContaining({ type: 'openParameter' }),
+                thoughtSpotHost,
+                expect.anything(),
+            );
+        });
+    });
+});
+
 // ---------------------------------------------------------------------------
 // 11 – AddColumns
 // ---------------------------------------------------------------------------
@@ -1633,3 +1665,165 @@ describe('context parameter forwarded in postMessage payload', () => {
         });
     });
 });
+
+// ---------------------------------------------------------------------------
+// SetVisibleVizs — array vizId injection (NOT in the parametrized arrayEvents)
+// ---------------------------------------------------------------------------
+describe('HostEvent.SetVisibleVizs — array payload vizId injection', () => {
+    test('vizId is added as a non-indexed property on the array — array.length unchanged', async () => {
+        mockMessageChannel();
+        const { lb, iframe } = await renderLiveboard({ vizId });
+        const arrayPayload = ['viz1', 'viz2'];
+        await executeAfterWait(() => {
+            lb.trigger(HostEvent.SetVisibleVizs, arrayPayload as any);
+            const call = (iframe.contentWindow.postMessage as jest.Mock).mock.calls[0];
+            const sentData = call[0].data;
+            expect((sentData as any).vizId).toBe(vizId);
+            expect(sentData.length).toBe(2);
+        });
+    });
+
+    test('without viewConfig.vizId — array payload is sent as-is (no vizId property)', async () => {
+        mockMessageChannel();
+        const { lb, iframe } = await renderLiveboard(); // no vizId
+        const arrayPayload = ['viz1'];
+        await executeAfterWait(() => {
+            lb.trigger(HostEvent.SetVisibleVizs, arrayPayload as any);
+            const call = (iframe.contentWindow.postMessage as jest.Mock).mock.calls[0];
+            const sentData = call[0].data;
+            expect((sentData as any).vizId).toBeUndefined();
+        });
+    });
+
+    test('returns null and calls handleError when !isRendered', async () => {
+        const lb = unrenderedLiveboard();
+        const result = await lb.trigger(HostEvent.SetVisibleVizs, ['viz1'] as any);
+        expect(result).toBeNull();
+        expect((lb as any).handleError).toHaveBeenCalledWith(
+            expect.objectContaining({ code: EmbedErrorCodes.RENDER_NOT_CALLED }),
+        );
+    });
+});
+
+// ---------------------------------------------------------------------------
+// UpdateRuntimeFilters — AppEmbed path (no vizId injection)
+// ---------------------------------------------------------------------------
+describe('HostEvent.UpdateRuntimeFilters — AppEmbed path', () => {
+    async function renderApp() {
+        const app = new AppEmbed(getRootEl(), {
+            frameParams: { width: '100%', height: '100%' },
+        });
+        await app.render();
+        const iframe = getIFrameEl();
+        jest.spyOn(iframe.contentWindow, 'postMessage');
+        return { app, iframe };
+    }
+
+    test('AppEmbed sends payload directly without vizId injection', async () => {
+        mockMessageChannel();
+        const { app, iframe } = await renderApp();
+        const filters = [{ columnName: 'col', operator: 'EQ', values: ['v1'] }];
+        await executeAfterWait(() => {
+            app.trigger(HostEvent.UpdateRuntimeFilters, filters as any);
+            const call = (iframe.contentWindow.postMessage as jest.Mock).mock.calls[0];
+            const sentData = call[0].data;
+            // Array payload with no vizId property injected
+            expect((sentData as any).vizId).toBeUndefined();
+            expect(sentData).toEqual(filters);
+        });
+    });
+});
+
+// ---------------------------------------------------------------------------
+// Present — vizId injection on LiveboardEmbed
+// ---------------------------------------------------------------------------
+describe('HostEvent.Present — vizId injection on LiveboardEmbed', () => {
+    test('viewConfig.vizId is injected into the Present payload', async () => {
+        mockMessageChannel();
+        const { lb, iframe } = await renderLiveboard({ vizId });
+        await executeAfterWait(() => {
+            lb.trigger(HostEvent.Present, {} as any);
+            expect(iframe.contentWindow.postMessage).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    data: expect.objectContaining({ vizId }),
+                }),
+                thoughtSpotHost,
+                expect.anything(),
+            );
+        });
+    });
+});
+
+// ---------------------------------------------------------------------------
+// DownloadAsCsv — additional cases
+// ---------------------------------------------------------------------------
+describe('HostEvent.DownloadAsCsv — additional cases', () => {
+    test('viewConfig.vizId overwrites an explicit payload vizId', async () => {
+        mockMessageChannel();
+        const { lb, iframe } = await renderLiveboard({ vizId });
+        await executeAfterWait(() => {
+            lb.trigger(HostEvent.DownloadAsCsv, { vizId: 'explicit-id' } as any);
+            const call = (iframe.contentWindow.postMessage as jest.Mock).mock.calls[0];
+            const sentData = call[0].data;
+            expect(sentData.vizId).toBe(vizId); // viewConfig.vizId wins
+        });
+    });
+
+    test('returns null and calls handleError when !isRendered', async () => {
+        const lb = unrenderedLiveboard();
+        const result = await lb.trigger(HostEvent.DownloadAsCsv, {} as any);
+        expect(result).toBeNull();
+        expect((lb as any).handleError).toHaveBeenCalledWith(
+            expect.objectContaining({ code: EmbedErrorCodes.RENDER_NOT_CALLED }),
+        );
+    });
+
+    test('returns null and logs debug when !iFrame', async () => {
+        const lb = new LiveboardEmbed(getRootEl(), {
+            frameParams: { width: '100%', height: '100%' },
+            liveboardId,
+        });
+        (lb as any).isRendered = true;
+        const result = await lb.trigger(HostEvent.DownloadAsCsv, {} as any);
+        expect(result).toBeNull();
+    });
+});
+
+// ---------------------------------------------------------------------------
+// Spotter share-conversation HostEvents 
+// ---------------------------------------------------------------------------
+describe('Spotter share-conversation HostEvents', () => {
+    const shareEvents: Array<[string, HostEvent, string, any]> = [
+        ['ShareSpotterConversation', HostEvent.ShareSpotterConversation, 'ShareSpotterConversation', { conversationId: 'abc' }],
+        ['CloseSpotterShareConversation', HostEvent.CloseSpotterShareConversation, 'CloseSpotterShareConversation', {}],
+        ['ExitSpotterSharedConversation', HostEvent.ExitSpotterSharedConversation, 'ExitSpotterSharedConversation', {}],
+    ];
+
+    test.each(shareEvents)(
+        '%s: postMessage type is the matching string value',
+        async (name, event, typeString, payload) => {
+            mockMessageChannel();
+            const { lb, iframe } = await renderLiveboard();
+            await executeAfterWait(() => {
+                lb.trigger(event, payload as any);
+                expect(iframe.contentWindow.postMessage).toHaveBeenCalledWith(
+                    expect.objectContaining({ type: typeString }),
+                    thoughtSpotHost,
+                    expect.anything(),
+                );
+            });
+        },
+    );
+
+    test.each(shareEvents)(
+        '%s: returns null and calls handleError when !isRendered',
+        async (name, event, typeString, payload) => {
+            const lb = unrenderedLiveboard();
+            const result = await lb.trigger(event, payload as any);
+            expect(result).toBeNull();
+            expect((lb as any).handleError).toHaveBeenCalledWith(
+                expect.objectContaining({ code: EmbedErrorCodes.RENDER_NOT_CALLED }),
+            );
+        },
+    );
+});

package/src/embed/hostEventClient/contracts.ts

@@ -7,6 +7,49 @@ export interface LiveboardTab {
   [key: string]: any;
 }
 
+export interface LiveboardGroup {
+  id: string;
+  name: string;
+  [key: string]: any;
+}
+
+/**
+ * Levels at which a filter or parameter can be applied.
+ */
+export enum ApplicabilityLevel {
+  Liveboard = 'LIVEBOARD',
+  Tab = 'TAB',
+  Group = 'GROUP',
+}
+
+/**
+ * Scopes a filter or parameter to a specific target.
+ * At `LIVEBOARD` level the filter applies to the whole Liveboard, so `targetId`
+ * is not required.
+ */
+export interface Applicability {
+  level: ApplicabilityLevel;
+  targetId?: string;
+}
+
+export interface FilterUpdate {
+  column: string;
+  oper: string;
+  values: string[];
+  type?: string;
+  applicability?: Applicability;
+}
+
+export interface LiveboardFilter {
+  applicability?: Applicability;
+  [key: string]: any;
+}
+
+export interface LiveboardParameter {
+  applicability?: Applicability;
+  [key: string]: any;
+}
+
 export enum UIPassthroughEvent {
   PinAnswerToLiveboard = 'addVizToPinboard',
   SaveAnswer = 'saveAnswer',
@@ -23,6 +66,7 @@ export enum UIPassthroughEvent {
   GetParameters = 'getParameters',
   GetTML = 'getTML',
   GetTabs = 'getTabs',
+  GetGroups = 'getGroups',
   GetExportRequestForCurrentPinboard = 'getExportRequestForCurrentPinboard',
 }
 
@@ -103,7 +147,7 @@ export type UIPassthroughContractBase = {
       vizId?: string;
     };
     response: {
-      liveboardFilters: Record<string, any>[];
+      liveboardFilters: LiveboardFilter[];
       runtimeFilters: RuntimeFilter[];
     };
   };
@@ -116,7 +160,7 @@ export type UIPassthroughContractBase = {
   [UIPassthroughEvent.GetParameters]: {
     request: Record<string, never>;
     response: {
-      parameters: Record<string, any>[];
+      parameters: LiveboardParameter[];
     };
   };
   [UIPassthroughEvent.GetTML]: {
@@ -134,6 +178,14 @@ export type UIPassthroughContractBase = {
       Tabs: LiveboardTab[];
     };
   };
+  [UIPassthroughEvent.GetGroups]: {
+    request: Record<string, never>;
+    response: {
+      orderedGroupIds: string[];
+      numberOfGroups: number;
+      Groups: LiveboardGroup[];
+    };
+  };
   [UIPassthroughEvent.GetExportRequestForCurrentPinboard]: {
     request: Record<string, never>;
     response: {
@@ -143,18 +195,8 @@ export type UIPassthroughContractBase = {
   };
   [UIPassthroughEvent.UpdateFilters]: {
     request: {
-      filter?: {
-        column: string;
-        oper: string;
-        values: string[];
-        type?: string;
-      };
-      filters?: {
-        column: string;
-        oper: string;
-        values: string[];
-        type?: string;
-      }[];
+      filter?: FilterUpdate;
+      filters?: FilterUpdate[];
     };
     response: unknown;
   };
@@ -198,6 +240,7 @@ export type EmbedApiHostEventMapping = {
   [HostEvent.GetParameters]: UIPassthroughEvent.GetParameters;
   [HostEvent.GetTML]: UIPassthroughEvent.GetTML;
   [HostEvent.GetTabs]: UIPassthroughEvent.GetTabs;
+  [HostEvent.GetGroups]: UIPassthroughEvent.GetGroups;
   [HostEvent.getExportRequestForCurrentPinboard]: UIPassthroughEvent.GetExportRequestForCurrentPinboard;
 }
 

package/src/embed/hostEventClient/host-event-client.spec.ts

@@ -311,6 +311,82 @@ describe('HostEventClient', () => {
             );
         });
 
+        it('should dispatch UpdateParameters over the legacy channel', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            const payload = [
+                { name: 'param1', value: 10, applicability: { level: 'TAB', targetId: 'tab-guid-1' } },
+            ] as any;
+            mockProcessTrigger.mockResolvedValueOnce({ success: true });
+
+            const result = await client.triggerHostEvent(HostEvent.UpdateParameters, payload);
+
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(1);
+            expect(mockProcessTrigger).toHaveBeenCalledWith(
+                mockIframe,
+                HostEvent.UpdateParameters,
+                mockThoughtSpotHost,
+                payload,
+                undefined,
+            );
+            expect(result).toEqual({ success: true });
+        });
+
+        it('should forward UpdateParameters with null applicability', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            const payload = [{ name: 'param1', value: 10, applicability: null }] as any;
+            mockProcessTrigger.mockResolvedValueOnce({ success: true });
+
+            await client.triggerHostEvent(HostEvent.UpdateParameters, payload);
+
+            expect(mockProcessTrigger).toHaveBeenCalledWith(
+                mockIframe,
+                HostEvent.UpdateParameters,
+                mockThoughtSpotHost,
+                payload,
+                undefined,
+            );
+        });
+
+        it('should throw when UpdateParameters entry has invalid applicability', async () => {
+            const { client } = createHostEventClient();
+            const invalidPayload = [
+                { name: 'param1', value: 10, applicability: { level: 'TAB' } }, // missing targetId
+            ] as any;
+
+            await expect(client.triggerHostEvent(HostEvent.UpdateParameters, invalidPayload))
+                .rejects.toThrow('UpdateParameters received an invalid applicability');
+            expect(mockProcessTrigger).not.toHaveBeenCalled();
+        });
+
+        it('should pass context to UpdateParameters event', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            const payload = [{ name: 'param1', value: 10 }] as any;
+            const context = { vizId: 'viz-1' } as any;
+            mockProcessTrigger.mockResolvedValueOnce({ success: true });
+
+            await client.triggerHostEvent(HostEvent.UpdateParameters, payload, context);
+
+            expect(mockProcessTrigger).toHaveBeenCalledWith(
+                mockIframe,
+                HostEvent.UpdateParameters,
+                mockThoughtSpotHost,
+                payload,
+                context,
+            );
+        });
+
+        it('should route GetGroups through passthrough and return data', async () => {
+            const { client } = createHostEventClient();
+            const mockResponse = [{ value: { orderedGroupIds: ['g1', 'g2'], numberOfGroups: 2, Groups: [] as any[] } }];
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce(mockResponse);
+
+            const result = await client.triggerHostEvent(HostEvent.GetGroups, {});
+
+            expect(result).toEqual({ orderedGroupIds: ['g1', 'g2'], numberOfGroups: 2, Groups: [] });
+        });
+
         it('should throw when DrillDown payload has no valid points', async () => {
             const { client } = createHostEventClient();
             const invalidPayload = {} as any;
@@ -816,4 +892,266 @@ describe('HostEventClient', () => {
             expect(result).toEqual({ ok: true });
         });
     });
+
+    describe('availablePassthroughKeysCache reuse', () => {
+        const allKeys = () => [{ value: { keys: Object.values(UIPassthroughEvent) } }];
+
+        it('GetFilters: second call reuses cache — GetAvailableUIPassthroughs called only once', async () => {
+            const { client } = createHostEventClient();
+            const filterResponse = [{ value: { liveboardFilters: [] as any[], runtimeFilters: [] as any[] } }];
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce(filterResponse)
+                .mockResolvedValueOnce(filterResponse);
+
+            await client.triggerHostEvent(HostEvent.GetFilters, {});
+            await client.triggerHostEvent(HostEvent.GetFilters, {});
+
+            // 3 calls total: 1 GetAvailableUIPassthroughs + 2 GetFilters
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(3);
+            expect(mockProcessTrigger).not.toHaveBeenNthCalledWith(
+                3,
+                expect.anything(),
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                expect.objectContaining({ type: UIPassthroughEvent.GetAvailableUIPassthroughs }),
+                undefined,
+            );
+        });
+
+        it('GetTabs: second call reuses cache — GetAvailableUIPassthroughs called only once', async () => {
+            const { client } = createHostEventClient();
+            const tabResponse = [{ value: { orderedTabIds: [] as any[], numberOfTabs: 0, Tabs: [] as any[] } }];
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce(tabResponse)
+                .mockResolvedValueOnce(tabResponse);
+
+            await client.triggerHostEvent(HostEvent.GetTabs, {});
+            await client.triggerHostEvent(HostEvent.GetTabs, {});
+
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(3);
+        });
+
+        it('GetParameters: second call reuses cache — GetAvailableUIPassthroughs called only once', async () => {
+            const { client } = createHostEventClient();
+            const paramResponse = [{ value: { parameters: [] as any[] } }];
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce(paramResponse)
+                .mockResolvedValueOnce(paramResponse);
+
+            await client.triggerHostEvent(HostEvent.GetParameters, {});
+            await client.triggerHostEvent(HostEvent.GetParameters, {});
+
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(3);
+        });
+
+        it('GetAnswerSession: second call reuses cache — GetAvailableUIPassthroughs called only once', async () => {
+            const { client } = createHostEventClient();
+            const sessionResponse = [{ value: { session: 's1' } }];
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce(sessionResponse)
+                .mockResolvedValueOnce(sessionResponse);
+
+            await client.triggerHostEvent(HostEvent.GetAnswerSession, {});
+            await client.triggerHostEvent(HostEvent.GetAnswerSession, {});
+
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(3);
+        });
+
+        it('UIPassthrough direct trigger does not populate the cache', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger.mockResolvedValue([{ value: { result: 'ok' } }]);
+
+            await client.triggerHostEvent(HostEvent.UIPassthrough, {});
+            // Cache not populated — next GetFilters call must still fetch keys
+            mockProcessTrigger.mockResolvedValueOnce(allKeys());
+            mockProcessTrigger.mockResolvedValueOnce([{ value: { liveboardFilters: [], runtimeFilters: [] as any[] } }]);
+            await client.triggerHostEvent(HostEvent.GetFilters, {});
+
+            // UIPassthrough call + GetAvailableUIPassthroughs + GetFilters = 3
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(3);
+        });
+
+        it('GetAnswerSession: catch in getAvailableUIPassthroughKeys does not cache, so next call retries GetAvailableUIPassthroughs', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger.mockReset();
+
+            // Flow per triggerHostEvent call when GetAvailableUIPassthroughs rejects:
+            //   1. getAvailableUIPassthroughKeys → processTrigger(UIPassthrough, GetAvailableUIPassthroughs) → rejects → returns []
+            //   2. keys=[] so getDataWithPassthroughFallback is called →
+            //      triggerUIPassthroughApi(GetAnswerSession) → processTrigger(UIPassthrough) → null → hostEventFallback called
+            //   3. hostEventFallback → processTrigger(GetAnswerSession) → legacy result
+
+            // First triggerHostEvent: 3 calls
+            mockProcessTrigger.mockRejectedValueOnce(new Error('network error')); // call 1
+            mockProcessTrigger.mockResolvedValueOnce(null);                       // call 2
+            mockProcessTrigger.mockResolvedValueOnce({ session: 'leg1' });        // call 3
+
+            await client.triggerHostEvent(HostEvent.GetAnswerSession, { vizId: '1' });
+
+            // Second triggerHostEvent: cache was NOT set, so GetAvailableUIPassthroughs is retried: 3 more calls
+            mockProcessTrigger.mockRejectedValueOnce(new Error('network error')); // call 4
+            mockProcessTrigger.mockResolvedValueOnce(null);                       // call 5
+            mockProcessTrigger.mockResolvedValueOnce({ session: 'leg2' });        // call 6
+
+            await client.triggerHostEvent(HostEvent.GetAnswerSession, { vizId: '2' });
+
+            // 6 total calls: GetAvailableUIPassthroughs was called TWICE (cache not set after catch)
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(6);
+            const availableCallsCount = mockProcessTrigger.mock.calls.filter(
+                (call) => call[3]?.type === UIPassthroughEvent.GetAvailableUIPassthroughs,
+            ).length;
+            expect(availableCallsCount).toBe(2);
+        });
+    });
+
+    describe('GetTML edge cases', () => {
+        const allKeys = () => [{ value: { keys: Object.values(UIPassthroughEvent) } }];
+
+        it('includeNonExecutedSearchTokens flag is forwarded in UIPassthrough parameters', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce([{ value: { tml: 'data' } }]);
+
+            await client.triggerHostEvent(HostEvent.GetTML, { includeNonExecutedSearchTokens: true } as any);
+
+            expect(mockProcessTrigger).toHaveBeenNthCalledWith(
+                2,
+                mockIframe,
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                {
+                    type: UIPassthroughEvent.GetTML,
+                    parameters: { includeNonExecutedSearchTokens: true },
+                },
+                undefined,
+            );
+        });
+
+        it('value.error (singular) throws — distinct from value.errors', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce([{ value: { error: 'TML fetch failed' } }]);
+
+            await expect(client.triggerHostEvent(HostEvent.GetTML, {}))
+                .rejects.toThrow('TML fetch failed');
+        });
+
+        it('GetTML key absent from non-empty keys array falls back to legacy hostEventFallback', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            // Return keys that do NOT include GetTML
+            mockProcessTrigger
+                .mockResolvedValueOnce([{ value: { keys: [UIPassthroughEvent.GetFilters] } }])
+                .mockResolvedValueOnce({ answer: { search_query: 'revenue' } });
+
+            const result = await client.triggerHostEvent(HostEvent.GetTML, {});
+
+            expect(mockProcessTrigger).toHaveBeenNthCalledWith(
+                2,
+                mockIframe,
+                HostEvent.GetTML,
+                mockThoughtSpotHost,
+                {},
+                undefined,
+            );
+            expect(result).toEqual({ answer: { search_query: 'revenue' } });
+        });
+    });
+
+    describe('SaveAnswer key-presence edge cases', () => {
+        const allKeys = () => [{ value: { keys: Object.values(UIPassthroughEvent) } }];
+        const saveResponse = [{
+            value: {
+                saveResponse: {
+                    data: {
+                        Answer__save: {
+                            answer: { id: 'ans123' },
+                        },
+                    },
+                },
+            },
+            refId: 'viz1',
+        }];
+
+        it('name+description both empty string route through passthrough, not Save fallback', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce(saveResponse);
+
+            await client.triggerHostEvent(HostEvent.SaveAnswer, { name: '', description: '' } as any);
+
+            expect(mockProcessTrigger).toHaveBeenNthCalledWith(
+                2,
+                mockIframe,
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                { type: UIPassthroughEvent.SaveAnswer, parameters: { name: '', description: '' } },
+                undefined,
+            );
+        });
+
+        it('description: undefined (key present) routes through passthrough, not Save fallback', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce(saveResponse);
+
+            await client.triggerHostEvent(HostEvent.SaveAnswer, { name: 'Test', description: undefined } as any);
+
+            expect(mockProcessTrigger).toHaveBeenNthCalledWith(
+                2,
+                mockIframe,
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                { type: UIPassthroughEvent.SaveAnswer, parameters: { name: 'Test', description: undefined } },
+                undefined,
+            );
+        });
+
+        it('name key absent falls back to HostEvent.Save', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce([saveResponse[0].value]);
+
+            await client.triggerHostEvent(HostEvent.SaveAnswer, { description: 'desc only' } as any);
+
+            expect(mockProcessTrigger).toHaveBeenCalledWith(
+                mockIframe,
+                HostEvent.Save,
+                mockThoughtSpotHost,
+                { description: 'desc only' },
+                undefined,
+            );
+        });
+
+        it('answerId is undefined when saveResponse.data.Answer__save.answer.id is missing', async () => {
+            const { client } = createHostEventClient();
+            const noIdSaveResponse = [{
+                value: {
+                    saveResponse: {
+                        data: {
+                            Answer__save: {
+                                answer: {},
+                            },
+                        },
+                    },
+                },
+                refId: 'viz1',
+            }];
+            mockProcessTrigger
+                .mockResolvedValueOnce(allKeys())
+                .mockResolvedValueOnce(noIdSaveResponse);
+
+            const result = await client.triggerHostEvent(HostEvent.SaveAnswer, { name: 'Test', description: 'Desc' } as any);
+
+            expect(result.answerId).toBeUndefined();
+        });
+    });
 });