@envive-ai/react-hooks 0.3.54 → 0.3.55

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+IGJvb2xlYW47XG5leHBvcnQgZGVjbGFyZSBlbnVtIFNlYXJjaFJlc3VsdHNTdGF0ZSB7XG4gICAgTG9hZGluZyA9IDAsXG4gICAgUmVzdWx0cyA9IDEsXG4gICAgTm9SZXN1bHRzID0gMlxufVxuZXhwb3J0IGRlY2xhcmUgY29uc3QgZ2V0U2VhcmNoUmVzdWx0c1N0YXRlOiAoaXNMb2FkaW5nU2VhcmNoOiBib29sZWFuLCBzZWFyY2hEYXRhOiBTZWFyY2hSZXN1bHQgfCBudWxsKSA9PiBTZWFyY2hSZXN1bHRzU3RhdGU7XG4iXSwibWFwcGluZ3MiOiI7Ozs7O0FBRUEsSUFBVyw0QkFBNEIsQ0FBQyxVQUFVLGVBQWU7QUFDakUsSUFBVyx1QkFBdUIsQ0FBQyxVQUFVLFVBQVU7QUFDdkQsSUFBVyx1QkFBdUI7Q0FBQztPQUFVO09BQWlCO09BQUE7Q0FBQTtBQUM5RCxJQUFXLHdCQUFpQixDQUFBLEdBQUE7QUFDNUIsSUFBVyxxQkFBZ0IsQ0FBQSxHQUFBO0FBQzNCLElBQVcsd0JBQXdCO0NBQUM7T0FBVTtPQUFvQjtDQUFtQiJ9
+//# 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.54",
+  "version": "0.3.55",
   "description": "React hooks for connecting to Envive AI services.",
   "keywords": [
     "react",

package/src/application/models/featureGates.ts

@@ -27,12 +27,20 @@ export enum FeatureGates {
   IsAiSuggestionsVariantEnabled = 'is_ai_suggestions_variant_enabled',
   IsAiSuggestionsVariantAEnabled = 'is_ai_suggestions_variant_a_enabled',
   IsAiSuggestionsVariantBEnabled = 'is_ai_suggestions_variant_b_enabled',
+  IsAiSuggestionsVariantCEnabled = 'is_ai_suggestions_variant_c_enabled',
+  IsAiSuggestionsVariantDEnabled = 'is_ai_suggestions_variant_d_enabled',
+  IsAiSuggestionsVariantEEnabled = 'is_ai_suggestions_variant_e_enabled',
+  IsAiSuggestionsVariantKEnabled = 'is_ai_suggestions_variant_k_enabled',
   // Serves the agentic storefront (FullPageSalesAgentV3 welcome overlay)
   // independently of the pdp/plp variant_b experiment. The backend serves the
   // storefront under this gate and falls back to variant_b only until this
   // ships, so an org can run the storefront without opting pdp/plp into variant_b.
   IsAiSuggestionsStorefrontEnabled = 'is_ai_suggestions_storefront_enabled',
   IsVoiceInputEnabled = 'is_voice_input_enabled',
+  // Resets the chat/conversation context to the new product when a PDP variant/color change
+  // updates the URL client-side (history.pushState/replaceState) without a full reload.
+  // Default OFF; enabled per-org via Statsig (initially Naturalizer) to de-risk rollout.
+  IsPdpVariantContextResetEnabled = 'is_pdp_variant_context_reset_enabled',
   // Statsig experiments / unified getWidgetConfig endpoint migration. When
   // true, EnviveConfigService calls getWidgetConfig (experiment-aware)
   // instead of the legacy getProductsConfigByVersion / getColorsAndFrontend

package/src/contexts/featureFlagServiceContext/featureFlagServiceContext.tsx

@@ -11,7 +11,12 @@ export interface FeatureFlagContextType {
   featureFlagService: FeatureFlagService | undefined;
 }
 
-const FeatureFlagServiceContext = createContext<FeatureFlagContextType | undefined>(undefined);
+// Exported so consumers that must not throw when a provider is absent (e.g. PageProvider
+// rendered bare in unit tests) can read it directly with `useContext` instead of the
+// throwing `useFeatureFlagService` hook.
+export const FeatureFlagServiceContext = createContext<FeatureFlagContextType | undefined>(
+  undefined,
+);
 
 interface FeatureFlagServiceProviderProps {
   featureFlagService: FeatureFlagService;

package/src/contexts/pageContext/__tests__/pageContext.test.tsx

@@ -11,6 +11,11 @@ import {
   pageVariantInfoAtom,
   urlResolverAtom,
 } from 'src/atoms/app/variant';
+import { FeatureGates } from 'src/application/models';
+import {
+  FeatureFlagService,
+  FeatureFlagServiceProvider,
+} from 'src/contexts/featureFlagServiceContext';
 import { mapUrlResolverResponseToVariantInfo } from '../mapping';
 import { PageProvider, usePage } from '../pageContext';
 
@@ -99,6 +104,21 @@ describe('PageProvider', () => {
     );
   };
 
+  // Same as renderWithProviders but with the PDP variant-reset feature gate turned on, so the
+  // client-side re-resolution behavior is exercised (it is gated off by default).
+  const renderWithVariantResetEnabled = (children: React.ReactNode, previewMode = false) => {
+    const featureFlagService = new FeatureFlagService([
+      { name: FeatureGates.IsPdpVariantContextResetEnabled, value: true },
+    ]);
+    return render(
+      <Provider>
+        <FeatureFlagServiceProvider featureFlagService={featureFlagService}>
+          <PageProvider previewMode={previewMode}>{children}</PageProvider>
+        </FeatureFlagServiceProvider>
+      </Provider>,
+    );
+  };
+
   describe('PageProvider Initialization', () => {
     it('should initialize with pageUrl from window.location.href', async () => {
       window.location.href = 'https://example.com/initial-page';
@@ -318,6 +338,255 @@ describe('PageProvider', () => {
     });
   });
 
+  describe('Client-side navigation (URL change without reload)', () => {
+    // Drives PageProvider via a changeable pageUrl so we can simulate a PDP variant/color
+    // swap that pushes a new URL without a full page reload.
+    const NavComponent: React.FC = () => {
+      const context = usePage();
+      return (
+        <div>
+          <div data-testid="variant-info">
+            {context.variantInfo ? JSON.stringify(context.variantInfo) : 'undefined'}
+          </div>
+          <button
+            type="button"
+            data-testid="navigate"
+            onClick={() => context.setPageUrl('https://example.com/product/variant-b')}
+          >
+            navigate
+          </button>
+        </div>
+      );
+    };
+
+    it('re-resolves to the new product when the page URL changes after initial resolution', async () => {
+      window.location.href = 'https://example.com/product/variant-a';
+
+      mockResolveUrl.mockImplementation(
+        async (url: string) =>
+          ({
+            variant_type: VariantTypeEnum.Pdp,
+            specific_details: {
+              pdp_attributes: {
+                product_id: url.includes('variant-b') ? 'product-b' : 'product-a',
+              },
+            },
+            ready: true,
+          }) as UrlResolverResponse,
+      );
+
+      renderWithVariantResetEnabled(<NavComponent />, false);
+
+      // Initial resolution to product-a
+      await waitFor(() => {
+        expect(screen.getByTestId('variant-info').textContent).toContain('product-a');
+      });
+      expect(mockResolveUrl).toHaveBeenCalledWith('https://example.com/product/variant-a');
+
+      // Simulate the SPA variant change pushing a new URL
+      await act(async () => {
+        screen.getByTestId('navigate').click();
+      });
+
+      // Even though the variant/userEvent atoms were already set, the new URL must re-resolve
+      await waitFor(() => {
+        expect(screen.getByTestId('variant-info').textContent).toContain('product-b');
+      });
+      expect(mockResolveUrl).toHaveBeenCalledWith('https://example.com/product/variant-b');
+    });
+
+    // Drives three sequential navigations via distinct buttons.
+    const MultiNavComponent: React.FC = () => {
+      const context = usePage();
+      return (
+        <div>
+          <div data-testid="variant-info">
+            {context.variantInfo ? JSON.stringify(context.variantInfo) : 'undefined'}
+          </div>
+          <button
+            type="button"
+            data-testid="go-b"
+            onClick={() => context.setPageUrl('https://example.com/product/variant-b')}
+          >
+            b
+          </button>
+          <button
+            type="button"
+            data-testid="go-c"
+            onClick={() => context.setPageUrl('https://example.com/product/variant-c')}
+          >
+            c
+          </button>
+        </div>
+      );
+    };
+
+    it('recovers on the next navigation after a resolver failure (does not permanently stop)', async () => {
+      window.location.href = 'https://example.com/product/variant-a';
+
+      mockResolveUrl.mockImplementation(async (url: string) => {
+        if (url.includes('variant-b')) {
+          throw new Error('transient resolver failure');
+        }
+        return {
+          variant_type: VariantTypeEnum.Pdp,
+          specific_details: {
+            pdp_attributes: {
+              product_id: url.includes('variant-c') ? 'product-c' : 'product-a',
+            },
+          },
+          ready: true,
+        } as UrlResolverResponse;
+      });
+
+      renderWithVariantResetEnabled(<MultiNavComponent />, false);
+
+      await waitFor(() => {
+        expect(screen.getByTestId('variant-info').textContent).toContain('product-a');
+      });
+
+      // Navigate to B — the resolver throws.
+      await act(async () => {
+        screen.getByTestId('go-b').click();
+      });
+      await waitFor(() => {
+        expect(mockResolveUrl).toHaveBeenCalledWith('https://example.com/product/variant-b');
+      });
+
+      // Navigate to C — resolution must still happen (the failure must not have permanently
+      // disabled re-resolution by poisoning the seed check).
+      await act(async () => {
+        screen.getByTestId('go-c').click();
+      });
+      await waitFor(() => {
+        expect(mockResolveUrl).toHaveBeenCalledWith('https://example.com/product/variant-c');
+      });
+      await waitFor(() => {
+        expect(screen.getByTestId('variant-info').textContent).toContain('product-c');
+      });
+    });
+
+    it('drops a stale out-of-order resolution without clobbering the newer product or clearing isLoading', async () => {
+      // Two rapid navigations where the OLDER url (a) resolves AFTER the newer one (b) has
+      // already started — common on slow/mobile networks. The stale response must be dropped,
+      // and it must NOT clear isLoading (the newer, still-pending request owns loading state).
+      window.location.href = 'https://example.com/product/variant-a';
+
+      let resolveA: (r: UrlResolverResponse) => void = () => {};
+      let resolveB: (r: UrlResolverResponse) => void = () => {};
+      const aPromise = new Promise<UrlResolverResponse>(res => {
+        resolveA = res;
+      });
+      const bPromise = new Promise<UrlResolverResponse>(res => {
+        resolveB = res;
+      });
+      mockResolveUrl.mockImplementation((url: string) =>
+        url.includes('variant-b') ? bPromise : aPromise,
+      );
+
+      const OutOfOrderComp: React.FC = () => {
+        const context = usePage();
+        return (
+          <div>
+            <div data-testid="variant-info">
+              {context.variantInfo ? JSON.stringify(context.variantInfo) : 'undefined'}
+            </div>
+            <div data-testid="is-loading">{context.isLoading ? 'true' : 'false'}</div>
+            <button
+              type="button"
+              data-testid="go-b"
+              onClick={() => context.setPageUrl('https://example.com/product/variant-b')}
+            >
+              b
+            </button>
+          </div>
+        );
+      };
+
+      renderWithVariantResetEnabled(<OutOfOrderComp />, false);
+
+      // Initial resolution of /a is in flight (aPromise pending).
+      await waitFor(() => {
+        expect(mockResolveUrl).toHaveBeenCalledWith('https://example.com/product/variant-a');
+      });
+
+      // Navigate to /b while /a is still pending.
+      await act(async () => {
+        screen.getByTestId('go-b').click();
+      });
+      await waitFor(() => {
+        expect(mockResolveUrl).toHaveBeenCalledWith('https://example.com/product/variant-b');
+      });
+
+      // The OLD /a resolves last (out of order), after /b became the current URL.
+      await act(async () => {
+        resolveA({
+          variant_type: VariantTypeEnum.Pdp,
+          specific_details: { pdp_attributes: { product_id: 'product-a' } },
+          ready: true,
+        } as UrlResolverResponse);
+      });
+
+      // Stale /a is dropped: it must not become the variant, and — critically — isLoading
+      // must stay true because /b is still resolving (this is Lucas's fix).
+      await waitFor(() => {
+        expect(screen.getByTestId('is-loading').textContent).toBe('true');
+      });
+      expect(screen.getByTestId('variant-info').textContent).not.toContain('product-a');
+
+      // /b resolves and wins.
+      await act(async () => {
+        resolveB({
+          variant_type: VariantTypeEnum.Pdp,
+          specific_details: { pdp_attributes: { product_id: 'product-b' } },
+          ready: true,
+        } as UrlResolverResponse);
+      });
+      await waitFor(() => {
+        expect(screen.getByTestId('variant-info').textContent).toContain('product-b');
+      });
+      await waitFor(() => {
+        expect(screen.getByTestId('is-loading').textContent).toBe('false');
+      });
+    });
+
+    it('does NOT re-resolve on a URL change when the feature gate is off (default)', async () => {
+      window.location.href = 'https://example.com/product/variant-a';
+
+      mockResolveUrl.mockImplementation(
+        async (url: string) =>
+          ({
+            variant_type: VariantTypeEnum.Pdp,
+            specific_details: {
+              pdp_attributes: { product_id: url.includes('variant-b') ? 'product-b' : 'product-a' },
+            },
+            ready: true,
+          }) as UrlResolverResponse,
+      );
+
+      // No FeatureFlagServiceProvider -> gate resolves to false -> original behavior.
+      renderWithProviders(<NavComponent />, false);
+
+      await waitFor(() => {
+        expect(screen.getByTestId('variant-info').textContent).toContain('product-a');
+      });
+
+      await act(async () => {
+        screen.getByTestId('navigate').click();
+      });
+      // Give any (unwanted) re-resolution time to happen.
+      await act(async () => {
+        await new Promise<void>(resolve => {
+          setTimeout(resolve, 100);
+        });
+      });
+
+      // The URL change must not have re-resolved; context stays on the original product.
+      expect(mockResolveUrl).not.toHaveBeenCalledWith('https://example.com/product/variant-b');
+      expect(screen.getByTestId('variant-info').textContent).toContain('product-a');
+    });
+  });
+
   describe('Variant Info Mapping', () => {
     it('should map PDP variant response correctly', async () => {
       const mockResponse: UrlResolverResponse = {

package/src/contexts/pageContext/pageContext.tsx

@@ -17,6 +17,8 @@ import {
   variantInfoAtom,
 } from 'src/atoms/app/variant';
 import { useAtom, useAtomValue } from 'jotai';
+import { FeatureGates } from 'src/application/models';
+import { FeatureFlagServiceContext } from 'src/contexts/featureFlagServiceContext';
 import CommerceApiClient from 'src/application/commerce-api';
 import Logger from 'src/application/logging/logger';
 import { PageVisitCategory, UserEventCategory } from '@spiffy-ai/commerce-api-client';
@@ -49,6 +51,25 @@ export const PageProvider: React.FC<{
   const [userEvent, setUserEvent] = useAtom(pageUserEventAtom);
   const [isSupported, setIsSupported] = useState(false);
   const lastNotReadyUrlRef = useRef<string | null>(null);
+  // Tracks the last URL we ran through the resolver (dedupe key). Lets us re-resolve when the
+  // page URL changes client-side (e.g. a PDP color/variant swap that pushes a new URL without
+  // a full reload) instead of short-circuiting on the stale variant/userEvent atoms. Cleared
+  // on failure so the URL can be retried.
+  const lastResolvedUrlRef = useRef<string | null>(null);
+  // Whether we have ever driven a resolution ourselves. Kept separate from
+  // `lastResolvedUrlRef` (which a failure clears) so a failed resolve can retry without the
+  // next navigation misreading it as "atoms were seeded externally" and skipping the API call.
+  const hasResolvedOnceRef = useRef(false);
+
+  // Gate: re-resolving the URL on a client-side change (PDP variant reset) is opt-in per org
+  // via Statsig. When off, keep the original behavior (resolve once, then short-circuit).
+  // Read via useContext (not useFeatureFlagService) so a bare PageProvider — e.g. in unit
+  // tests — does not throw; absent provider or gate resolves to false.
+  const featureFlagContext = useContext(FeatureFlagServiceContext);
+  const isVariantResetEnabled =
+    featureFlagContext?.featureFlagService?.isFeatureGateEnabled(
+      FeatureGates.IsPdpVariantContextResetEnabled,
+    ) ?? false;
 
   useEffect(() => {
     setPageUrl(window.location.href);
@@ -101,16 +122,54 @@ export const PageProvider: React.FC<{
           return;
         }
 
-        // If in preview mode or atoms are already set (e.g., by storybook), skip API call
-        if (previewMode || userEvent || variantInfo) {
-          setIsLoading(false);
-          return;
+        const cleansedUrl = pageUrl.toLowerCase().trim();
+
+        if (!isVariantResetEnabled) {
+          // Gate off: original behavior — resolve once, then short-circuit forever while the
+          // variant/userEvent atoms are set (a client-side URL change never re-resolves).
+          if (previewMode || userEvent || variantInfo) {
+            setIsLoading(false);
+            return;
+          }
+        } else {
+          // Gate on: re-resolve when the URL changes so a PDP variant swap follows to the new
+          // product.
+          //
+          // Already resolved this exact URL — guards against the effect re-running once the
+          // resolver writes the variant/userEvent atoms (they are effect dependencies).
+          if (lastResolvedUrlRef.current === cleansedUrl) {
+            setIsLoading(false);
+            return;
+          }
+          // In preview mode, or when the atoms were seeded externally (e.g. by storybook)
+          // before we ourselves resolved anything, honor those atoms and skip the API call.
+          // Once we have resolved at least once (`hasResolvedOnceRef`), a changed URL should
+          // re-resolve even though the previous variant/userEvent atoms are set.
+          if (previewMode || ((userEvent || variantInfo) && !hasResolvedOnceRef.current)) {
+            hasResolvedOnceRef.current = true;
+            lastResolvedUrlRef.current = cleansedUrl;
+            setIsLoading(false);
+            return;
+          }
+          hasResolvedOnceRef.current = true;
+          lastResolvedUrlRef.current = cleansedUrl;
         }
 
-        const cleansedUrl = pageUrl.toLowerCase().trim();
         const response =
           urlResolverResponse[cleansedUrl] ??
           ((await CommerceApiClient.resolveUrl(cleansedUrl)) as UrlResolverResponse);
+
+        // A newer navigation started resolving while we awaited (e.g. the shopper clicked
+        // through several variant swatches quickly). Drop this now-stale response so an
+        // out-of-order resolution can't overwrite the latest variant. Do NOT clear isLoading
+        // here: the newer in-flight request owns the loading state, and clearing it would
+        // open a window where isLoading=false while variantInfo/isSupported still belong to
+        // the previous product (causing widget flashes and a fire-once success ref — see
+        // Widgets.tsx — to latch onto the wrong product's state).
+        if (isVariantResetEnabled && lastResolvedUrlRef.current !== cleansedUrl) {
+          return;
+        }
+
         setVariantFromUrlResolver(cleansedUrl, response);
         setIsLoading(false);
         setIsSupported(response.ready);
@@ -125,6 +184,14 @@ export const PageProvider: React.FC<{
           });
         }
       } catch (e) {
+        // Allow this URL to be retried on a subsequent trigger — but only if a newer
+        // navigation hasn't already superseded it, so a stale failure can't discard a newer
+        // in-flight resolution. `hasResolvedOnceRef` is intentionally left set, so retrying
+        // never falls into the seeded-atoms branch above.
+        const failedUrl = pageUrl?.toLowerCase().trim();
+        if (failedUrl && lastResolvedUrlRef.current === failedUrl) {
+          lastResolvedUrlRef.current = null;
+        }
         setIsLoading(false);
         logger.logError('Failed to resolve page URL', e, { pageUrl });
       }
@@ -139,6 +206,7 @@ export const PageProvider: React.FC<{
     variantInfo,
     previewMode,
     onUrlResolverNotReady,
+    isVariantResetEnabled,
   ]);
 
   const { trackEvent } = useAmplitude();