@thoughtspot/visual-embed-sdk 1.46.5-beta.1 → 1.46.5

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

@@ -125,6 +125,8 @@ describe('HostEventClient', () => {
     });
 
     describe('executeHostEvent', () => {
+        const mockGetAvailablePassthroughs = () => [{ value: { keys: Object.values(UIPassthroughEvent) } }];
+
         it('should call handleUIPassthroughForHostEvent for Pin event', async () => {
             const { client, mockIframe } = createHostEventClient();
             const hostEvent = HostEvent.Pin;
@@ -140,7 +142,9 @@ describe('HostEventClient', () => {
                 },
             };
 
-            mockProcessTrigger.mockResolvedValue([mockResponse]);
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce([mockResponse]);
 
             const result = await client.triggerHostEvent(hostEvent, payload);
 
@@ -176,7 +180,9 @@ describe('HostEventClient', () => {
                 },
                 refId: 'testVizId',
             }];
-            mockProcessTrigger.mockResolvedValue(mockResponse);
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce(mockResponse);
             const result = await client.triggerHostEvent(hostEvent, payload);
 
             expect(mockProcessTrigger).toHaveBeenCalledWith(
@@ -192,6 +198,168 @@ describe('HostEventClient', () => {
             expect(result).toEqual({ answerId: 'newAnswer', ...mockResponse[0].value });
         });
 
+        it('should call handleHostEventWithParam for UpdateFilters event', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            const hostEvent = HostEvent.UpdateFilters;
+            const payload: HostEventRequest<typeof hostEvent> = {
+                vizId: 'viz-123',
+                filter: {
+                    column: 'region',
+                    oper: 'EQ',
+                    values: ['North'],
+                },
+            } as any;
+            const mockResponse = [{ value: { success: true } }];
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce(mockResponse);
+
+            const result = await client.triggerHostEvent(hostEvent, payload);
+
+            expect(mockProcessTrigger).toHaveBeenCalledWith(
+                mockIframe,
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                {
+                    type: UIPassthroughEvent.UpdateFilters,
+                    parameters: payload,
+                },
+                undefined,
+            );
+            expect(result).toEqual({ success: true });
+        });
+
+        it('should call handleHostEventWithParam for DrillDown event', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            const hostEvent = HostEvent.DrillDown;
+            const payload: HostEventRequest<typeof hostEvent> = {
+                points: { clickedPoint: 'point-1', selectedPoints: ['sel-1'] },
+                autoDrillDown: true,
+            } as any;
+            const mockResponse = [{ value: { drillDownApplied: true } }];
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce(mockResponse);
+
+            const result = await client.triggerHostEvent(hostEvent, payload);
+
+            expect(mockProcessTrigger).toHaveBeenCalledWith(
+                mockIframe,
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                {
+                    type: UIPassthroughEvent.Drilldown,
+                    parameters: payload,
+                },
+                undefined,
+            );
+            expect(result).toEqual({ drillDownApplied: true });
+        });
+
+        it('should accept UpdateFilters with filters array', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            const payload = {
+                filters: [
+                    { column: '(Sample) Retail - Apparel::city', oper: 'IN', values: ['atlanta'] },
+                    { column: '(Sample) Retail - Apparel::Region', oper: 'IN', values: ['West', 'Midwest'] },
+                ],
+            } as any;
+            const mockResponse = [{ value: { success: true } }];
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce(mockResponse);
+
+            const result = await client.triggerHostEvent(HostEvent.UpdateFilters, payload);
+
+            expect(mockProcessTrigger).toHaveBeenNthCalledWith(
+                2,
+                mockIframe,
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                { type: UIPassthroughEvent.UpdateFilters, parameters: payload },
+                undefined,
+            );
+            expect(result).toEqual({ success: true });
+        });
+
+        it('should throw when UpdateFilters payload has no valid filter', async () => {
+            const { client } = createHostEventClient();
+            const invalidPayload = {} as any;
+            mockProcessTrigger.mockResolvedValueOnce(mockGetAvailablePassthroughs());
+
+            await expect(client.triggerHostEvent(HostEvent.UpdateFilters, invalidPayload))
+                .rejects.toThrow('UpdateFilters requires a valid filter or filters array');
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(1);
+        });
+
+        it('should pass context to UpdateFilters event', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            const payload = { vizId: 'viz-1', filter: { column: 'x', oper: 'EQ', values: ['a'] } } as any;
+            const context = { answerId: 'ans-1' } as any;
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce([{ value: {} }]);
+
+            await client.triggerHostEvent(HostEvent.UpdateFilters, payload, context);
+
+            expect(mockProcessTrigger).toHaveBeenCalledWith(
+                mockIframe,
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                { type: UIPassthroughEvent.UpdateFilters, parameters: payload },
+                context,
+            );
+        });
+
+        it('should throw when DrillDown payload has no valid points', async () => {
+            const { client } = createHostEventClient();
+            const invalidPayload = {} as any;
+            mockProcessTrigger.mockResolvedValueOnce(mockGetAvailablePassthroughs());
+
+            await expect(client.triggerHostEvent(HostEvent.DrillDown, invalidPayload))
+                .rejects.toThrow('DrillDown requires a valid points object');
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(1);
+        });
+
+        it('should pass context to DrillDown event', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            const payload = { points: { clickedPoint: 'point-1' }, vizId: 'viz-2' } as any;
+            const context = { liveboardId: 'lb-1' } as any;
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce([{ value: {} }]);
+
+            await client.triggerHostEvent(HostEvent.DrillDown, payload, context);
+
+            expect(mockProcessTrigger).toHaveBeenCalledWith(
+                mockIframe,
+                HostEvent.UIPassthrough,
+                mockThoughtSpotHost,
+                { type: UIPassthroughEvent.Drilldown, parameters: payload },
+                context,
+            );
+        });
+
+        it('should skip to fallback when passthrough is not in available keys', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce([{ value: { keys: ['getFilters'] } }])
+                .mockResolvedValueOnce({ session: 'legacySession' });
+
+            const result = await client.triggerHostEvent(HostEvent.GetAnswerSession, { vizId: '123' });
+
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(2);
+            expect(mockProcessTrigger).toHaveBeenNthCalledWith(
+                2,
+                mockIframe,
+                HostEvent.GetAnswerSession,
+                mockThoughtSpotHost,
+                { vizId: '123' },
+                undefined,
+            );
+            expect(result).toEqual({ session: 'legacySession' });
+        });
+
         it('should call hostEventFallback for unmapped events', async () => {
             const { client } = createHostEventClient();
             const hostEvent = 'testEvent' as HostEvent;
@@ -208,11 +376,14 @@ describe('HostEventClient', () => {
         it('should route GetAnswerSession through passthrough and return data', async () => {
             const { client, mockIframe } = createHostEventClient();
             const mockResponse = [{ value: { session: 'testSession', embedAnswerData: { id: '1' } } }];
-            mockProcessTrigger.mockResolvedValue(mockResponse);
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce(mockResponse);
 
             const result = await client.triggerHostEvent(HostEvent.GetAnswerSession, { vizId: '123' });
 
-            expect(mockProcessTrigger).toHaveBeenCalledWith(
+            expect(mockProcessTrigger).toHaveBeenNthCalledWith(
+                2,
                 mockIframe,
                 HostEvent.UIPassthrough,
                 mockThoughtSpotHost,
@@ -225,14 +396,15 @@ describe('HostEventClient', () => {
         it('should fall back to legacy host event when passthrough returns no data for GetAnswerSession', async () => {
             const { client } = createHostEventClient();
             mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
                 .mockResolvedValueOnce([])
                 .mockResolvedValueOnce({ session: 'fallbackSession' });
 
             const result = await client.triggerHostEvent(HostEvent.GetAnswerSession, { vizId: '123' });
 
-            expect(mockProcessTrigger).toHaveBeenCalledTimes(2);
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(3);
             expect(mockProcessTrigger).toHaveBeenNthCalledWith(
-                2,
+                3,
                 expect.anything(),
                 HostEvent.GetAnswerSession,
                 mockThoughtSpotHost,
@@ -244,17 +416,21 @@ describe('HostEventClient', () => {
 
         it('should throw real errors from passthrough without falling back', async () => {
             const { client } = createHostEventClient();
-            mockProcessTrigger.mockResolvedValue([{ error: 'Permission denied' }]);
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce([{ error: 'Permission denied' }]);
 
             await expect(client.triggerHostEvent(HostEvent.GetAnswerSession, {}))
                 .rejects.toThrow('Permission denied');
-            expect(mockProcessTrigger).toHaveBeenCalledTimes(1);
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(2);
         });
 
         it('should route GetFilters through passthrough and return data', async () => {
             const { client, mockIframe } = createHostEventClient();
             const mockResponse = [{ value: { liveboardFilters: [{ id: 'f1' }], runtimeFilters: [] as any[] } }];
-            mockProcessTrigger.mockResolvedValue(mockResponse);
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce(mockResponse);
 
             const result = await client.triggerHostEvent(HostEvent.GetFilters, {});
 
@@ -271,7 +447,9 @@ describe('HostEventClient', () => {
         it('should route GetTabs through passthrough and return data', async () => {
             const { client } = createHostEventClient();
             const mockResponse = [{ value: { orderedTabIds: ['t1', 't2'], numberOfTabs: 2, Tabs: [] as any[] } }];
-            mockProcessTrigger.mockResolvedValue(mockResponse);
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce(mockResponse);
 
             const result = await client.triggerHostEvent(HostEvent.GetTabs, {});
 
@@ -281,7 +459,9 @@ describe('HostEventClient', () => {
         it('should route GetTML through passthrough and return data', async () => {
             const { client } = createHostEventClient();
             const tmlData = { answer: { search_query: 'revenue by region' } };
-            mockProcessTrigger.mockResolvedValue([{ value: tmlData }]);
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce([{ value: tmlData }]);
 
             const result = await client.triggerHostEvent(HostEvent.GetTML, {});
 
@@ -290,7 +470,9 @@ describe('HostEventClient', () => {
 
         it('should route GetIframeUrl through passthrough and return data', async () => {
             const { client } = createHostEventClient();
-            mockProcessTrigger.mockResolvedValue([{ value: { iframeUrl: 'https://ts.example.com/embed' } }]);
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce([{ value: { iframeUrl: 'https://ts.example.com/embed' } }]);
 
             const result = await client.triggerHostEvent(HostEvent.GetIframeUrl, {});
 
@@ -299,7 +481,9 @@ describe('HostEventClient', () => {
 
         it('should route GetParameters through passthrough and return data', async () => {
             const { client } = createHostEventClient();
-            mockProcessTrigger.mockResolvedValue([{ value: { parameters: [{ name: 'p1' }] } }]);
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce([{ value: { parameters: [{ name: 'p1' }] } }]);
 
             const result = await client.triggerHostEvent(HostEvent.GetParameters, {});
 
@@ -308,7 +492,9 @@ describe('HostEventClient', () => {
 
         it('should route getExportRequestForCurrentPinboard through passthrough and return data', async () => {
             const { client } = createHostEventClient();
-            mockProcessTrigger.mockResolvedValue([{ value: { v2Content: 'exportData' } }]);
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce([{ value: { v2Content: 'exportData' } }]);
 
             const result = await client.triggerHostEvent(HostEvent.getExportRequestForCurrentPinboard, {});
 
@@ -318,12 +504,13 @@ describe('HostEventClient', () => {
         it('should fall back to legacy for GetFilters when passthrough returns null', async () => {
             const { client } = createHostEventClient();
             mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
                 .mockResolvedValueOnce(null)
                 .mockResolvedValueOnce({ liveboardFilters: [], runtimeFilters: [] });
 
             const result = await client.triggerHostEvent(HostEvent.GetFilters, {});
 
-            expect(mockProcessTrigger).toHaveBeenCalledTimes(2);
+            expect(mockProcessTrigger).toHaveBeenCalledTimes(3);
             expect(result).toEqual({ liveboardFilters: [], runtimeFilters: [] });
         });
 
@@ -339,7 +526,9 @@ describe('HostEventClient', () => {
                 },
             };
 
-            mockProcessTrigger.mockResolvedValue([mockResponse]);
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce([mockResponse]);
 
             const result = await client.triggerHostEvent(hostEvent, payload);
 
@@ -365,7 +554,9 @@ describe('HostEventClient', () => {
                 },
             };
 
-            mockProcessTrigger.mockResolvedValue([mockResponse]);
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce([mockResponse]);
 
             const result = await client.triggerHostEvent(hostEvent, payload);
 
@@ -397,7 +588,9 @@ describe('HostEventClient', () => {
                 },
                 refId: 'testVizId',
             }];
-            mockProcessTrigger.mockResolvedValue(mockResponse);
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce(mockResponse);
             const result = await client.triggerHostEvent(hostEvent, payload);
             expect(result.liveboardId).toBe('testLiveboard');
         });
@@ -419,7 +612,9 @@ describe('HostEventClient', () => {
                 },
                 refId: 'testVizId',
             }];
-            mockProcessTrigger.mockResolvedValue(mockResponse);
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockGetAvailablePassthroughs())
+                .mockResolvedValueOnce(mockResponse);
             const result = await client.triggerHostEvent(hostEvent, payload);
             expect(result.liveboardId).toBe('testLiveboard');
             expect(mockProcessTrigger).toHaveBeenCalledWith(
@@ -575,4 +770,50 @@ describe('HostEventClient', () => {
             );
         });
     });
+
+    describe('UI passthrough available keys tests', () => {
+        const mockKeys = () => [{ value: { keys: Object.values(UIPassthroughEvent) } }];
+
+        it('triggerHostEvent Pin returns passthrough response', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockKeys())
+                .mockResolvedValueOnce([{ value: { pinboardId: 'lb1', tabId: 't1', vizId: 'v1' } }]);
+
+            const result = await client.triggerHostEvent(HostEvent.Pin, { newVizName: 'Viz' });
+
+            expect(result).toMatchObject({ pinboardId: 'lb1', liveboardId: 'lb1' });
+        });
+
+        it('triggerHostEvent GetAnswerSession returns session', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger
+                .mockResolvedValueOnce(mockKeys())
+                .mockResolvedValueOnce([{ value: { session: 's1' } }]);
+
+            const result = await client.triggerHostEvent(HostEvent.GetAnswerSession, {});
+
+            expect(result).toEqual({ session: 's1' });
+        });
+
+        it('triggerHostEvent unmapped event uses fallback', async () => {
+            const { client } = createHostEventClient();
+            mockProcessTrigger.mockResolvedValue({ data: 'legacy' });
+
+            const result = await client.triggerHostEvent('unknownEvent' as HostEvent, {});
+
+            expect(mockProcessTrigger).toHaveBeenCalledWith(expect.anything(), 'unknownEvent', mockThoughtSpotHost, {}, undefined);
+            expect(result).toEqual({ data: 'legacy' });
+        });
+
+        it('hostEventFallback delegates to processTrigger', async () => {
+            const { client, mockIframe } = createHostEventClient();
+            mockProcessTrigger.mockResolvedValue({ ok: true });
+
+            const result = await client.hostEventFallback(HostEvent.Save, { x: 1 });
+
+            expect(mockProcessTrigger).toHaveBeenCalledWith(mockIframe, HostEvent.Save, mockThoughtSpotHost, { x: 1 }, undefined);
+            expect(result).toEqual({ ok: true });
+        });
+    });
 });

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

@@ -1,6 +1,12 @@
 import { ContextType, HostEvent } from '../../types';
 import { processTrigger as processTriggerService } from '../../utils/processTrigger';
 import { getEmbedConfig } from '../embedConfig';
+import {
+    isValidUpdateFiltersPayload,
+    isValidDrillDownPayload,
+    throwUpdateFiltersValidationError,
+    throwDrillDownValidationError,
+} from './utils';
 import {
     UIPassthroughArrayResponse,
     UIPassthroughEvent,
@@ -12,8 +18,18 @@ import {
     TriggerResponse,
 } from './contracts';
 
-/** Host events that use getDataWithPassthroughFallback (getter-style APIs) */
-const HOST_EVENT_PASSTHROUGH_MAP: Partial<Record<HostEvent, UIPassthroughEvent>> = {
+/**
+ * Maps HostEvent to its corresponding UIPassthroughEvent.
+ * Includes both custom-handler events (Pin, SaveAnswer, UpdateFilters, DrillDown)
+ * and getter events (GetAnswerSession, GetFilters, etc.) that use getDataWithPassthroughFallback.
+ */
+const PASSTHROUGH_MAP: Partial<Record<HostEvent, UIPassthroughEvent>> = {
+    // Custom handlers (setters with special logic)
+    [HostEvent.Pin]: UIPassthroughEvent.PinAnswerToLiveboard,
+    [HostEvent.SaveAnswer]: UIPassthroughEvent.SaveAnswer,
+    [HostEvent.UpdateFilters]: UIPassthroughEvent.UpdateFilters,
+    [HostEvent.DrillDown]: UIPassthroughEvent.Drilldown,
+    // Getters (use getDataWithPassthroughFallback)
     [HostEvent.GetAnswerSession]: UIPassthroughEvent.GetAnswerSession,
     [HostEvent.GetFilters]: UIPassthroughEvent.GetFilters,
     [HostEvent.GetIframeUrl]: UIPassthroughEvent.GetIframeUrl,
@@ -26,6 +42,9 @@ const HOST_EVENT_PASSTHROUGH_MAP: Partial<Record<HostEvent, UIPassthroughEvent>>
 export class HostEventClient {
   iFrame: HTMLIFrameElement;
 
+  /** Cached list of available UI passthrough keys from the embedded app */
+  private availablePassthroughKeysCache: string[] | null = null;
+
   /** Host events with custom handlers 
    * (setters or special logic) - 
    * bound to instance for protected method access */
@@ -38,6 +57,8 @@ export class HostEventClient {
       this.customHandlers = {
           [HostEvent.Pin]: (p, c) => this.handlePinEvent(p, c),
           [HostEvent.SaveAnswer]: (p, c) => this.handleSaveAnswerEvent(p, c),
+          [HostEvent.UpdateFilters]: (p, c) => this.handleUpdateFiltersEvent(p, c),
+          [HostEvent.DrillDown]: (p, c) => this.handleDrillDownEvent(p, c),
       };
   }
 
@@ -133,6 +154,27 @@ export class HostEventClient {
       this.iFrame = iFrame;
   }
 
+  /**
+   * Fetches the list of available UI passthrough keys from the embedded app.
+   * Result is cached for the session. Returns empty array on failure.
+   */
+  private async getAvailableUIPassthroughKeys(context?: ContextType): Promise<string[]> {
+      if (this.availablePassthroughKeysCache !== null) {
+          return this.availablePassthroughKeysCache;
+      }
+      try {
+          const response = await this.triggerUIPassthroughApi(
+              UIPassthroughEvent.GetAvailableUIPassthroughs, {}, context,
+          );
+          const matched = response?.find?.((r) => r.value && !r.error);
+          const keys = matched?.value?.keys;
+          this.availablePassthroughKeysCache = Array.isArray(keys) ? keys : [];
+          return this.availablePassthroughKeysCache;
+      } catch {
+          return [];
+      }
+  }
+
   public async triggerUIPassthroughApi<UIPassthroughEventT extends UIPassthroughEvent>(
       apiName: UIPassthroughEventT,
       parameters: UIPassthroughRequest<UIPassthroughEventT>,
@@ -190,6 +232,37 @@ export class HostEventClient {
       };
   }
 
+  protected handleUpdateFiltersEvent(
+    payload: HostEventRequest<HostEvent.UpdateFilters>,
+    context?: ContextType,
+  ): Promise<any> {
+    if (!isValidUpdateFiltersPayload(payload)) {
+      throwUpdateFiltersValidationError();
+    }
+
+    return this.handleHostEventWithParam(UIPassthroughEvent.UpdateFilters, payload, context as ContextType);
+  }
+
+  protected handleDrillDownEvent(
+    payload: HostEventRequest<HostEvent.DrillDown>,
+    context?: ContextType,
+  ): Promise<any> {
+    if (!isValidDrillDownPayload(payload)) {
+      throwDrillDownValidationError();
+    }
+
+    return this.handleHostEventWithParam(UIPassthroughEvent.Drilldown, payload, context as ContextType);
+  }
+
+  /**
+   * Dispatches a host event using the appropriate channel:
+   * 1. If the embedded app supports UI passthrough for this event, use it (custom handler or getter).
+   * 2. Otherwise fall back to the legacy host event channel.
+   *
+   * @param hostEvent - The host event to trigger
+   * @param payload - Optional payload for the event
+   * @param context - Optional context (e.g. vizId) for scoped operations
+   */
   public async triggerHostEvent<
     HostEventT extends HostEvent,
     PayloadT,
@@ -200,17 +273,20 @@ export class HostEventClient {
       context?: ContextT,
   ): Promise<TriggerResponse<PayloadT, HostEventT, ContextType>> {
       const customHandler = this.customHandlers[hostEvent];
-      if (customHandler) {
-          return customHandler(payload, context as ContextType) as any;
-      }
+      const passthroughEvent = PASSTHROUGH_MAP[hostEvent];
 
-      const passthroughEvent = HOST_EVENT_PASSTHROUGH_MAP[hostEvent];
-      if (passthroughEvent) {
-          return this.getDataWithPassthroughFallback(
-              passthroughEvent, hostEvent, payload, context as ContextType,
-          ) as any;
+      // If embedded app supports passthrough but not this event, use legacy channel
+      const keys = passthroughEvent ? await this.getAvailableUIPassthroughKeys(context as ContextType) : [];
+      if (passthroughEvent && keys.length > 0 && !keys.includes(passthroughEvent)) {
+          return this.hostEventFallback(hostEvent, payload, context) as any;
       }
 
-      return this.hostEventFallback(hostEvent, payload, context);
+      // Custom handler (setters) > getter passthrough > legacy fallback
+      return (customHandler
+          ? customHandler(payload, context as ContextType)
+          : passthroughEvent
+              ? this.getDataWithPassthroughFallback(passthroughEvent, hostEvent, payload, context as ContextType)
+              : this.hostEventFallback(hostEvent, payload, context)
+      ) as any;
   }
 }