@envive-ai/react-hooks 0.3.59 → 0.3.61

package/dist/hooks/TrackComponentVisibleEvent/useTrackComponentVisibleEvent.cjs

@@ -28,7 +28,7 @@ const safeNow = () => {
 	}
 };
 const useTrackComponentVisibleEvent = (element, eventProps, rootMargin = "0px", enabled = true) => {
-	const isVisible = require_useIntersection.useIntersection(element, rootMargin);
+	const isVisible = require_useIntersection.useIntersection(element, rootMargin, eventProps);
 	const hasTrackedEvent = (0, react.useRef)(false);
 	const { trackEvent } = require_amplitudeContext.useAmplitude();
 	const variantInfo = (0, jotai.useAtomValue)(require_variant.pageVariantInfoAtom);
@@ -78,4 +78,4 @@ const useTrackComponentVisibleEvent = (element, eventProps, rootMargin = "0px",
 
 //#endregion
 exports.useTrackComponentVisibleEvent = useTrackComponentVisibleEvent;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/hooks/TrackComponentVisibleEvent/useTrackComponentVisibleEvent.js

@@ -27,7 +27,7 @@ const safeNow = () => {
 	}
 };
 const useTrackComponentVisibleEvent = (element, eventProps, rootMargin = "0px", enabled = true) => {
-	const isVisible = useIntersection(element, rootMargin);
+	const isVisible = useIntersection(element, rootMargin, eventProps);
 	const hasTrackedEvent = useRef(false);
 	const { trackEvent } = useAmplitude();
 	const variantInfo = useAtomValue(pageVariantInfoAtom);
@@ -77,4 +77,4 @@ const useTrackComponentVisibleEvent = (element, eventProps, rootMargin = "0px",
 
 //#endregion
 export { useTrackComponentVisibleEvent };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/dist/hooks/utils.d.cts

@@ -19,4 +19,4 @@ declare enum SearchResultsState {
 declare const getSearchResultsState: (isLoadingSearch: boolean, searchData: SearchResult | null) => SearchResultsState;
 //#endregion
 export { SearchResultsState, createAppLoadedEvent, createVisitUserEvent, getSearchResultsState, isElementPartiallyVisible, isWithinBusinessHours };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC5jdHMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL2hvb2tzL3V0aWxzLmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2VhcmNoUmVzdWx0IH0gZnJvbSAnc3JjL2FwcGxpY2F0aW9uL21vZGVscy9hcGkvc2VhcmNoJztcbmltcG9ydCB7IFVzZXJFdmVudCwgVmFyaWFudEluZm8gfSBmcm9tICdzcmMvYXBwbGljYXRpb24vbW9kZWxzJztcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGlzRWxlbWVudFBhcnRpYWxseVZpc2libGU6IChlbD86IEhUTUxEaXZFbGVtZW50IHwgbnVsbCkgPT4gYm9vbGVhbjtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGNyZWF0ZUFwcExvYWRlZEV2ZW50OiAoKSA9PiBVc2VyRXZlbnQ7XG5leHBvcnQgZGVjbGFyZSBjb25zdCBjcmVhdGVWaXNpdFVzZXJFdmVudDogKHsgdmFyaWFudEluZm8sIH06IHtcbiAgICB2YXJpYW50SW5mbzogVmFyaWFudEluZm87XG59KSA9PiBVc2VyRXZlbnQgfCB1bmRlZmluZWQ7XG5leHBvcnQgZGVjbGFyZSBjb25zdCBpc1dpdGhpbkJ1c2luZXNzSG91cnM6IChzdGFydFRpbWU6IHN0cmluZywgZW5kVGltZTogc3RyaW5nLCB0aW1lWm9uZTogc3RyaW5nKSA9PiBib29sZWFuO1xuZXhwb3J0IGRlY2xhcmUgZW51bSBTZWFyY2hSZXN1bHRzU3RhdGUge1xuICAgIExvYWRpbmcgPSAwLFxuICAgIFJlc3VsdHMgPSAxLFxuICAgIE5vUmVzdWx0cyA9IDJcbn1cbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGdldFNlYXJjaFJlc3VsdHNTdGF0ZTogKGlzTG9hZGluZ1NlYXJjaDogYm9vbGVhbiwgc2VhcmNoRGF0YTogU2VhcmNoUmVzdWx0IHwgbnVsbCkgPT4gU2VhcmNoUmVzdWx0c1N0YXRlO1xuIl0sIm1hcHBpbmdzIjoiOzs7OztBQUVBLElBQVcsNEJBQTRCLENBQUMsU0FBUyxlQUFlO0FBQ2hFLElBQVcsdUJBQXVCLENBQUMsU0FBUyxVQUFVO0FBQ3RELElBQVcsdUJBQXVCO0NBQUM7T0FBUztPQUFrQjtPQUFBO0NBQUE7QUFDOUQsSUFBVyx3QkFBaUIsQ0FBQSxFQUFBO0FBQzVCLElBQVcscUJBQWdCLENBQUEsRUFBQTtBQUMzQixJQUFXLHdCQUF3QjtDQUFDO09BQVM7T0FBb0I7Q0FBbUIifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC5jdHMiLCJuYW1lcyI6W10sInNvdXJjZXMiOlsiLi4vLi4vc3JjL2hvb2tzL3V0aWxzLmQudHMiXSwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgU2VhcmNoUmVzdWx0IH0gZnJvbSAnc3JjL2FwcGxpY2F0aW9uL21vZGVscy9hcGkvc2VhcmNoJztcbmltcG9ydCB7IFVzZXJFdmVudCwgVmFyaWFudEluZm8gfSBmcm9tICdzcmMvYXBwbGljYXRpb24vbW9kZWxzJztcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGlzRWxlbWVudFBhcnRpYWxseVZpc2libGU6IChlbD86IEhUTUxEaXZFbGVtZW50IHwgbnVsbCkgPT4gYm9vbGVhbjtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGNyZWF0ZUFwcExvYWRlZEV2ZW50OiAoKSA9PiBVc2VyRXZlbnQ7XG5leHBvcnQgZGVjbGFyZSBjb25zdCBjcmVhdGVWaXNpdFVzZXJFdmVudDogKHsgdmFyaWFudEluZm8sIH06IHtcbiAgICB2YXJpYW50SW5mbzogVmFyaWFudEluZm87XG59KSA9PiBVc2VyRXZlbnQgfCB1bmRlZmluZWQ7XG5leHBvcnQgZGVjbGFyZSBjb25zdCBpc1dpdGhpbkJ1c2luZXNzSG91cnM6IChzdGFydFRpbWU6IHN0cmluZywgZW5kVGltZTogc3RyaW5nLCB0aW1lWm9uZTogc3RyaW5nKSA9PiBib29sZWFuO1xuZXhwb3J0IGRlY2xhcmUgZW51bSBTZWFyY2hSZXN1bHRzU3RhdGUge1xuICAgIExvYWRpbmcgPSAwLFxuICAgIFJlc3VsdHMgPSAxLFxuICAgIE5vUmVzdWx0cyA9IDJcbn1cbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGdldFNlYXJjaFJlc3VsdHNTdGF0ZTogKGlzTG9hZGluZ1NlYXJjaDogYm9vbGVhbiwgc2VhcmNoRGF0YTogU2VhcmNoUmVzdWx0IHwgbnVsbCkgPT4gU2VhcmNoUmVzdWx0c1N0YXRlO1xuIl0sIm1hcHBpbmdzIjoiOzs7OztBQUVBLElBQVcsNEJBQTRCLENBQUMsV0FBVyxlQUFlO0FBQ2xFLElBQVcsdUJBQXVCLENBQUMsV0FBVyxVQUFVO0FBQ3hELElBQVcsdUJBQXVCO0NBQUM7T0FBVztPQUFnQjtPQUFBO0NBQUE7QUFDOUQsSUFBVyx3QkFBaUIsQ0FBQSxJQUFBO0FBQzVCLElBQVcscUJBQWdCLENBQUEsSUFBQTtBQUMzQixJQUFXLHdCQUF3QjtDQUFDO09BQVc7T0FBb0I7Q0FBbUIifQ==

package/dist/hooks/utils.d.ts

@@ -19,4 +19,4 @@ declare enum SearchResultsState {
 declare const getSearchResultsState: (isLoadingSearch: boolean, searchData: SearchResult | null) => SearchResultsState;
 //#endregion
 export { SearchResultsState, createAppLoadedEvent, createVisitUserEvent, getSearchResultsState, isElementPartiallyVisible, isWithinBusinessHours };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi9zcmMvaG9va3MvdXRpbHMuZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTZWFyY2hSZXN1bHQgfSBmcm9tICdzcmMvYXBwbGljYXRpb24vbW9kZWxzL2FwaS9zZWFyY2gnO1xuaW1wb3J0IHsgVXNlckV2ZW50LCBWYXJpYW50SW5mbyB9IGZyb20gJ3NyYy9hcHBsaWNhdGlvbi9tb2RlbHMnO1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgaXNFbGVtZW50UGFydGlhbGx5VmlzaWJsZTogKGVsPzogSFRNTERpdkVsZW1lbnQgfCBudWxsKSA9PiBib29sZWFuO1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgY3JlYXRlQXBwTG9hZGVkRXZlbnQ6ICgpID0+IFVzZXJFdmVudDtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGNyZWF0ZVZpc2l0VXNlckV2ZW50OiAoeyB2YXJpYW50SW5mbywgfToge1xuICAgIHZhcmlhbnRJbmZvOiBWYXJpYW50SW5mbztcbn0pID0+IFVzZXJFdmVudCB8IHVuZGVmaW5lZDtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGlzV2l0aGluQnVzaW5lc3NIb3VyczogKHN0YXJ0VGltZTogc3RyaW5nLCBlbmRUaW1lOiBzdHJpbmcsIHRpbWVab25lOiBzdHJpbmcpID0+IGJvb2xlYW47XG5leHBvcnQgZGVjbGFyZSBlbnVtIFNlYXJjaFJlc3VsdHNTdGF0ZSB7XG4gICAgTG9hZGluZyA9IDAsXG4gICAgUmVzdWx0cyA9IDEsXG4gICAgTm9SZXN1bHRzID0gMlxufVxuZXhwb3J0IGRlY2xhcmUgY29uc3QgZ2V0U2VhcmNoUmVzdWx0c1N0YXRlOiAoaXNMb2FkaW5nU2VhcmNoOiBib29sZWFuLCBzZWFyY2hEYXRhOiBTZWFyY2hSZXN1bHQgfCBudWxsKSA9PiBTZWFyY2hSZXN1bHRzU3RhdGU7XG4iXSwibWFwcGluZ3MiOiI7Ozs7O0FBRUEsSUFBVyw0QkFBNEIsQ0FBQyxTQUFTLGVBQWU7QUFDaEUsSUFBVyx1QkFBdUIsQ0FBQyxTQUFTLFVBQVU7QUFDdEQsSUFBVyx1QkFBdUI7Q0FBQztPQUFVO09BQWlCO09BQUE7Q0FBQTtBQUM5RCxJQUFXLHdCQUFpQixDQUFBLEdBQUE7QUFDNUIsSUFBVyxxQkFBZ0IsQ0FBQSxHQUFBO0FBQzNCLElBQVcsd0JBQXdCO0NBQUM7T0FBVTtPQUFvQjtDQUFtQiJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuZC50cyIsIm5hbWVzIjpbXSwic291cmNlcyI6WyIuLi8uLi9zcmMvaG9va3MvdXRpbHMuZC50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBTZWFyY2hSZXN1bHQgfSBmcm9tICdzcmMvYXBwbGljYXRpb24vbW9kZWxzL2FwaS9zZWFyY2gnO1xuaW1wb3J0IHsgVXNlckV2ZW50LCBWYXJpYW50SW5mbyB9IGZyb20gJ3NyYy9hcHBsaWNhdGlvbi9tb2RlbHMnO1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgaXNFbGVtZW50UGFydGlhbGx5VmlzaWJsZTogKGVsPzogSFRNTERpdkVsZW1lbnQgfCBudWxsKSA9PiBib29sZWFuO1xuZXhwb3J0IGRlY2xhcmUgY29uc3QgY3JlYXRlQXBwTG9hZGVkRXZlbnQ6ICgpID0+IFVzZXJFdmVudDtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGNyZWF0ZVZpc2l0VXNlckV2ZW50OiAoeyB2YXJpYW50SW5mbywgfToge1xuICAgIHZhcmlhbnRJbmZvOiBWYXJpYW50SW5mbztcbn0pID0+IFVzZXJFdmVudCB8IHVuZGVmaW5lZDtcbmV4cG9ydCBkZWNsYXJlIGNvbnN0IGlzV2l0aGluQnVzaW5lc3NIb3VyczogKHN0YXJ0VGltZTogc3RyaW5nLCBlbmRUaW1lOiBzdHJpbmcsIHRpbWVab25lOiBzdHJpbmcpID0+IGJvb2xlYW47XG5leHBvcnQgZGVjbGFyZSBlbnVtIFNlYXJjaFJlc3VsdHNTdGF0ZSB7XG4gICAgTG9hZGluZyA9IDAsXG4gICAgUmVzdWx0cyA9IDEsXG4gICAgTm9SZXN1bHRzID0gMlxufVxuZXhwb3J0IGRlY2xhcmUgY29uc3QgZ2V0U2VhcmNoUmVzdWx0c1N0YXRlOiAoaXNMb2FkaW5nU2VhcmNoOiBib29sZWFuLCBzZWFyY2hEYXRhOiBTZWFyY2hSZXN1bHQgfCBudWxsKSA9PiBTZWFyY2hSZXN1bHRzU3RhdGU7XG4iXSwibWFwcGluZ3MiOiI7Ozs7O0FBRUEsSUFBVyw0QkFBNEIsQ0FBQyxTQUFTLGVBQWU7QUFDaEUsSUFBVyx1QkFBdUIsQ0FBQyxTQUFTLFVBQVU7QUFDdEQsSUFBVyx1QkFBdUI7Q0FBQztPQUFTO09BQWtCO09BQUE7Q0FBQTtBQUM5RCxJQUFXLHdCQUFpQixDQUFBLEVBQUE7QUFDNUIsSUFBVyxxQkFBZ0IsQ0FBQSxFQUFBO0FBQzNCLElBQVcsd0JBQXdCO0NBQUM7T0FBUztPQUFvQjtDQUFtQiJ9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@envive-ai/react-hooks",
-  "version": "0.3.59",
+  "version": "0.3.61",
   "description": "React hooks for connecting to Envive AI services.",
   "keywords": [
     "react",

package/src/contexts/typesV3.ts

@@ -407,6 +407,13 @@ interface FullPageSalesAgentWidgetV3Config extends BaseWidgetConfig<WidgetTypeV3
   chatBackgroundColor?: string;
   suggestionButtonType?: PromptButtonVariant;
   productCarouselLayout?: ProductCarouselLayoutV3;
+  /**
+   * When true (or unset), asking a question opens the conversation in a
+   * partial-height sheet that keeps the welcome overlay's product grid
+   * visible above it. Set to false to fall back to the full-screen takeover.
+   * Default true (undefined and true = partial view enabled).
+   */
+  partialViewEnabled?: boolean;
 }
 
 type WidgetConfigV3 =

package/src/hooks/Intersection/__tests__/useIntersection.test.ts

@@ -1,6 +1,12 @@
 import { act, renderHook } from '@testing-library/react';
 import { RefObject } from 'react';
-import { useIntersection } from '../useIntersection';
+import Logger from 'src/application/logging/logger';
+import {
+  VISIBILITY_FALLBACK_GRACE_MS,
+  VISIBILITY_FALLBACK_INTERVAL_MS,
+  VISIBILITY_FOREGROUND_GRACE_MS,
+  useIntersection,
+} from '../useIntersection';
 
 class MockIntersectionObserver {
   static instances: MockIntersectionObserver[] = [];
@@ -131,4 +137,223 @@ describe('useIntersection', () => {
 
     expect(lastObserver().disconnected).toBe(true);
   });
+
+  describe('visibility fallback', () => {
+    let logErrorSpy: ReturnType<typeof vi.spyOn>;
+
+    const rect = (partial: Partial<DOMRect>): DOMRect => {
+      const base = {
+        top: 0,
+        left: 0,
+        bottom: 0,
+        right: 0,
+        x: 0,
+        y: 0,
+        toJSON: () => ({}),
+        ...partial,
+      };
+      // Derive area from the bounds like a real DOMRect, unless explicitly overridden, so
+      // the on-screen guard (width/height > 0) sees realistic geometry.
+      return {
+        ...base,
+        width: partial.width ?? base.right - base.left,
+        height: partial.height ?? base.bottom - base.top,
+      } as DOMRect;
+    };
+
+    const connectedNode = (nodeRect: Partial<DOMRect>) => {
+      const node = document.createElement('span');
+      document.body.appendChild(node);
+      vi.spyOn(node, 'getBoundingClientRect').mockReturnValue(rect(nodeRect));
+      return node;
+    };
+
+    beforeEach(() => {
+      vi.useFakeTimers();
+      logErrorSpy = vi.spyOn(Logger.prototype, 'logError').mockImplementation(() => {});
+    });
+
+    afterEach(() => {
+      vi.useRealTimers();
+      logErrorSpy.mockRestore();
+      document.body.innerHTML = '';
+    });
+
+    it('reports visibility and logs an error when an on-screen element is never reported by the observer', () => {
+      const node = connectedNode({ top: 100, bottom: 300, left: 0, right: 200 });
+      const ref: RefObject<HTMLElement> = { current: node };
+
+      const { result } = renderHook(() =>
+        useIntersection(ref, '0px', { widget_type: 'ProductCardV3' }),
+      );
+      expect(result.current).toBe(false);
+
+      // First check happens after the grace window.
+      act(() => {
+        vi.advanceTimersByTime(VISIBILITY_FALLBACK_GRACE_MS);
+      });
+
+      expect(result.current).toBe(true);
+      expect(logErrorSpy).toHaveBeenCalledTimes(1);
+      const [message, , context] = logErrorSpy.mock.calls[0];
+      expect(message).toContain('Visibility fallback engaged');
+      expect(context).toMatchObject({ widget_type: 'ProductCardV3' });
+
+      // Fires at most once — once visible, the reconciliation loop stops
+      act(() => {
+        vi.advanceTimersByTime(VISIBILITY_FALLBACK_INTERVAL_MS * 3);
+      });
+      expect(logErrorSpy).toHaveBeenCalledTimes(1);
+    });
+
+    it('does not engage for an element that is genuinely off screen', () => {
+      const node = connectedNode({ top: 5000, bottom: 5200, left: 0, right: 200 });
+      const ref: RefObject<HTMLElement> = { current: node };
+
+      const { result } = renderHook(() => useIntersection(ref, '0px'));
+
+      act(() => {
+        vi.advanceTimersByTime(VISIBILITY_FALLBACK_GRACE_MS + VISIBILITY_FALLBACK_INTERVAL_MS * 4);
+      });
+
+      expect(result.current).toBe(false);
+      expect(logErrorSpy).not.toHaveBeenCalled();
+    });
+
+    it('does not engage when the observer reports visibility first', () => {
+      const node = connectedNode({ top: 100, bottom: 300, left: 0, right: 200 });
+      const ref: RefObject<HTMLElement> = { current: node };
+
+      const { result } = renderHook(() => useIntersection(ref, '0px'));
+      act(() => {
+        lastObserver().fire(true, node);
+      });
+      expect(result.current).toBe(true);
+
+      act(() => {
+        vi.advanceTimersByTime(VISIBILITY_FALLBACK_GRACE_MS + VISIBILITY_FALLBACK_INTERVAL_MS * 4);
+      });
+
+      expect(logErrorSpy).not.toHaveBeenCalled();
+    });
+
+    it('does not engage for a detached node', () => {
+      const node = document.createElement('span');
+      vi.spyOn(node, 'getBoundingClientRect').mockReturnValue(
+        rect({ top: 100, bottom: 300, left: 0, right: 200 }),
+      );
+      const ref: RefObject<HTMLElement> = { current: node };
+
+      const { result } = renderHook(() => useIntersection(ref, '0px'));
+
+      act(() => {
+        vi.advanceTimersByTime(VISIBILITY_FALLBACK_GRACE_MS + VISIBILITY_FALLBACK_INTERVAL_MS * 4);
+      });
+
+      expect(result.current).toBe(false);
+      expect(logErrorSpy).not.toHaveBeenCalled();
+    });
+
+    it('recovers on foreground (visibilitychange) without waiting for the poll interval', () => {
+      const node = connectedNode({ top: 100, bottom: 300, left: 0, right: 200 });
+      const ref: RefObject<HTMLElement> = { current: node };
+
+      const { result } = renderHook(() =>
+        useIntersection(ref, '0px', { widget_type: 'ProductCardV3' }),
+      );
+      expect(result.current).toBe(false);
+
+      // Tab returns to foreground; the grace is far shorter than the poll interval.
+      act(() => {
+        document.dispatchEvent(new Event('visibilitychange'));
+        vi.advanceTimersByTime(VISIBILITY_FOREGROUND_GRACE_MS);
+      });
+
+      expect(result.current).toBe(true);
+      expect(logErrorSpy).toHaveBeenCalledTimes(1);
+      expect(logErrorSpy.mock.calls[0][2]).toMatchObject({ widget_type: 'ProductCardV3' });
+    });
+
+    it('does not engage on foreground when the observer re-fires within the grace window', () => {
+      const node = connectedNode({ top: 100, bottom: 300, left: 0, right: 200 });
+      const ref: RefObject<HTMLElement> = { current: node };
+
+      const { result } = renderHook(() => useIntersection(ref, '0px'));
+
+      // Foreground schedules the grace check...
+      act(() => {
+        document.dispatchEvent(new Event('visibilitychange'));
+      });
+      // ...but a healthy observer re-fires first (in its own flush, as it would in the
+      // browser within a frame), flipping isVisible and tearing down the grace timer.
+      act(() => {
+        lastObserver().fire(true, node);
+      });
+      act(() => {
+        vi.advanceTimersByTime(VISIBILITY_FOREGROUND_GRACE_MS * 2);
+      });
+
+      expect(result.current).toBe(true);
+      expect(logErrorSpy).not.toHaveBeenCalled();
+    });
+
+    it('does not engage on foreground while the document is still hidden', () => {
+      const node = connectedNode({ top: 100, bottom: 300, left: 0, right: 200 });
+      const ref: RefObject<HTMLElement> = { current: node };
+      const visibilitySpy = vi.spyOn(document, 'visibilityState', 'get').mockReturnValue('hidden');
+
+      const { result } = renderHook(() => useIntersection(ref, '0px'));
+
+      act(() => {
+        document.dispatchEvent(new Event('visibilitychange'));
+        vi.advanceTimersByTime(VISIBILITY_FOREGROUND_GRACE_MS);
+      });
+
+      expect(result.current).toBe(false);
+      expect(logErrorSpy).not.toHaveBeenCalled();
+      visibilitySpy.mockRestore();
+    });
+
+    it('does not engage for a zero-area element within the viewport (unlaid-out / collapsed)', () => {
+      // An inline wrapper that has not laid out its content yet reports a zero-area rect at
+      // a viewport position. That is genuinely not-visible, not something the observer missed.
+      const node = connectedNode({ top: 100, bottom: 100, left: 50, right: 50 });
+      const ref: RefObject<HTMLElement> = { current: node };
+
+      const { result } = renderHook(() => useIntersection(ref, '0px'));
+
+      act(() => {
+        vi.advanceTimersByTime(VISIBILITY_FALLBACK_GRACE_MS + VISIBILITY_FALLBACK_INTERVAL_MS * 4);
+      });
+
+      expect(result.current).toBe(false);
+      expect(logErrorSpy).not.toHaveBeenCalled();
+    });
+
+    it('recovers a stuck on-screen element even while the document is hidden, but stays silent', () => {
+      // The environments this fallback exists for — iOS/WebKit in-app webviews and bfcache
+      // restores — can report the document as hidden while the shopper is actually looking at
+      // it, so recovery must NOT be gated on visibility (that was the CircleCI failure: a
+      // headless page reports non-visible and the widget never un-stuck). The error, however,
+      // is only a genuine signal when the page is visible — a suppressed observer in a real
+      // background tab is expected, not a bug — so it must not fire here and flood telemetry.
+      const node = connectedNode({ top: 100, bottom: 300, left: 0, right: 200 });
+      const ref: RefObject<HTMLElement> = { current: node };
+      const visibilitySpy = vi
+        .spyOn(document, 'visibilityState', 'get')
+        .mockReturnValue('hidden');
+
+      const { result } = renderHook(() =>
+        useIntersection(ref, '0px', { widget_type: 'ProductCardV3' }),
+      );
+
+      act(() => {
+        vi.advanceTimersByTime(VISIBILITY_FALLBACK_GRACE_MS);
+      });
+
+      expect(result.current).toBe(true); // recovered despite being "hidden"
+      expect(logErrorSpy).not.toHaveBeenCalled(); // but no false-positive error logged
+      visibilitySpy.mockRestore();
+    });
+  });
 });

package/src/hooks/Intersection/useIntersection.ts

@@ -3,11 +3,49 @@ import Logger from 'src/application/logging/logger';
 
 const logger = new Logger('useIntersection');
 
+// How long to wait before the fallback's FIRST reconcile. Long enough that a healthy
+// IntersectionObserver has delivered its initial callback (so we don't falsely flag a
+// normally-loading widget), short enough to keep the worst-case blank window small.
+// Exported for tests.
+export const VISIBILITY_FALLBACK_GRACE_MS = 1000;
+
+// How often the fallback re-checks after the initial grace. A genuinely stuck widget
+// recovers within grace + one interval (~1.3s). Exported for tests.
+export const VISIBILITY_FALLBACK_INTERVAL_MS = 300;
+
+// After the tab returns to the foreground, how long to wait before the fast-path reconcile —
+// long enough for a healthy observer to re-fire on its own (so we don't falsely flag it),
+// short enough that recovery is near-instant. Exported for tests.
+export const VISIBILITY_FOREGROUND_GRACE_MS = 200;
+
+const isOnScreen = (node: HTMLElement): boolean => {
+  const rect = node.getBoundingClientRect();
+  // Require real area: an element that has not laid out yet (a 0×0 inline wrapper mid-mount)
+  // or is collapsed to zero by an overflow-clipping ancestor is not something the observer
+  // wrongly missed — it is genuinely not visible. display:none subtrees report an all-zero
+  // rect and are excluded here too.
+  if (rect.width <= 0 || rect.height <= 0) {
+    return false;
+  }
+  return (
+    rect.top < window.innerHeight &&
+    rect.bottom > 0 &&
+    rect.left < window.innerWidth &&
+    rect.right > 0
+  );
+};
+
 // https://rasilbaidar.medium.com/trigger-event-when-element-enters-viewport-the-react-way-168509da2e23
-export const useIntersection = (element: RefObject<HTMLElement>, rootMargin: string) => {
+export const useIntersection = (
+  element: RefObject<HTMLElement>,
+  rootMargin: string,
+  logContext?: Record<string, unknown>,
+) => {
   const [isVisible, setIsVisible] = useState(false);
   const observerRef = useRef<IntersectionObserver | null>(null);
   const observedNodeRef = useRef<HTMLElement | null>(null);
+  const logContextRef = useRef(logContext);
+  logContextRef.current = logContext;
 
   // Runs after every render so it catches when element.current transitions from null to a
   // mounted DOM node, AND when the node under the ref is replaced. The replacement case is
@@ -18,35 +56,18 @@ export const useIntersection = (element: RefObject<HTMLElement>, rootMargin: str
   // keeping per-render cost O(1).
   useEffect(() => {
     const current = element?.current;
-    logger.logDebug('effect ran', {
-      elementCurrent: current,
-      rootMargin,
-      alreadyObserving: !!observerRef.current,
-      observingCurrentNode: observedNodeRef.current === current,
-    });
-
     if (!current) {
-      logger.logDebug('element.current is null — observer NOT attached');
       return;
     }
     if (observedNodeRef.current === current) return; // already observing this exact node
 
     if (observerRef.current) {
-      logger.logDebug('observed node was replaced — re-attaching observer', {
-        previousNode: observedNodeRef.current,
-        newNode: current,
-      });
+      // Node under the ref was replaced — drop the observer on the detached node.
       observerRef.current.disconnect();
     }
 
     const observer = new IntersectionObserver(
       ([entry]) => {
-        logger.logDebug('IntersectionObserver fired', {
-          isIntersecting: entry.isIntersecting,
-          intersectionRatio: entry.intersectionRatio,
-          boundingClientRect: entry.boundingClientRect,
-          target: entry.target,
-        });
         setIsVisible(entry.isIntersecting);
       },
       { rootMargin },
@@ -55,9 +76,80 @@ export const useIntersection = (element: RefObject<HTMLElement>, rootMargin: str
     observer.observe(current);
     observerRef.current = observer;
     observedNodeRef.current = current;
-    logger.logDebug('observer attached to element', current);
   });
 
+  // Safety net: visibility detection must not be a single point of failure. While the
+  // observer reports not-visible, periodically reconcile against the element's actual
+  // position; an element that is on screen while the observer stayed silent means
+  // observation is broken for a reason we haven't met yet (wrapped/overridden
+  // IntersectionObserver, engine quirk, a failure mode like the stale-node bug). Report it
+  // as a console error (so session tools can count affected sessions) and treat the
+  // element as visible so it still loads.
+  useEffect(() => {
+    if (isVisible) {
+      return undefined;
+    }
+
+    const reconcile = () => {
+      const node = element?.current;
+      if (!node || !node.isConnected) {
+        return;
+      }
+      if (isOnScreen(node)) {
+        // Recover the widget regardless of document.visibilityState. The environments this
+        // fallback exists for — iOS/WebKit in-app webviews and bfcache restores — can report
+        // the document as hidden even while the shopper is looking at it, so gating recovery
+        // on visibility would defeat the fix in exactly those cases. Only LOG a genuine
+        // failure when the page is actually visible, so a legitimately suppressed observer in
+        // a hidden/background tab does not flood error telemetry with false positives.
+        if (document.visibilityState === 'visible') {
+          logger.logError(
+            'Visibility fallback engaged — element is on screen but IntersectionObserver never reported it',
+            undefined,
+            {
+              ...logContextRef.current,
+              fallback_interval_ms: VISIBILITY_FALLBACK_INTERVAL_MS,
+            },
+          );
+        }
+        setIsVisible(true);
+      }
+    };
+
+    // Give the real observer a grace window to deliver its initial callback, then poll on a
+    // shorter cadence so a genuinely stuck widget recovers quickly.
+    let interval: ReturnType<typeof setInterval> | undefined;
+    const grace = setTimeout(() => {
+      reconcile();
+      interval = setInterval(reconcile, VISIBILITY_FALLBACK_INTERVAL_MS);
+    }, VISIBILITY_FALLBACK_GRACE_MS);
+
+    // Fast path: a widget composited while the tab was hidden can have its
+    // IntersectionObserver suppressed, and some engines fail to re-fire it when the tab
+    // returns to the foreground for an element already in the viewport. On visibility
+    // change, reconcile after a short grace — if a healthy observer re-fires first,
+    // isVisible flips and this effect tears the timer down before it runs.
+    let foregroundCheck: ReturnType<typeof setTimeout> | undefined;
+    const onVisibilityChange = () => {
+      if (document.visibilityState !== 'visible') {
+        return;
+      }
+      foregroundCheck = setTimeout(reconcile, VISIBILITY_FOREGROUND_GRACE_MS);
+    };
+    document.addEventListener('visibilitychange', onVisibilityChange);
+
+    return () => {
+      clearTimeout(grace);
+      if (interval !== undefined) {
+        clearInterval(interval);
+      }
+      document.removeEventListener('visibilitychange', onVisibilityChange);
+      if (foregroundCheck !== undefined) {
+        clearTimeout(foregroundCheck);
+      }
+    };
+  }, [isVisible, element]);
+
   // Disconnect on unmount only — intentionally separate from the setup effect above.
   useEffect(() => {
     return () => {

package/src/hooks/TrackComponentVisibleEvent/useTrackComponentVisibleEvent.ts

@@ -35,7 +35,9 @@ export const useTrackComponentVisibleEvent = (
   rootMargin: string = '0px',
   enabled: boolean = true,
 ): { isVisible: boolean } => {
-  const isVisible = useIntersection(element, rootMargin);
+  // eventProps (widget_config_id, widget_type, …) double as log context so the hook's
+  // visibility-fallback error identifies which widget it rescued.
+  const isVisible = useIntersection(element, rootMargin, eventProps);
   const hasTrackedEvent = useRef(false);
   const { trackEvent } = useAmplitude();
   const variantInfo = useAtomValue(pageVariantInfoAtom);