@envive-ai/react-hooks 0.3.62 → 0.3.64

package/src/hooks/WidgetLoadDiagnostics/__tests__/useWidgetLoadDiagnostics.test.ts

@@ -0,0 +1,161 @@
+import { act, renderHook } from '@testing-library/react';
+import { WidgetTypeV3 } from 'src/contexts/typesV3';
+import {
+  WIDGET_LOAD_STALL_MS,
+  WidgetLoadDiagnosticsInput,
+  useWidgetLoadDiagnostics,
+} from '../useWidgetLoadDiagnostics';
+
+const trackEvent = vi.fn();
+
+vi.mock('src/contexts/amplitudeContext/amplitudeContext', () => ({
+  useAmplitude: () => ({ trackEvent, isReady: true }),
+}));
+
+// Keep jotai's atom() working; only stub useAtomValue so we don't need a Provider.
+vi.mock('jotai', async (importOriginal: () => Promise<typeof import('jotai')>) => {
+  const actual = await importOriginal();
+  return { ...actual, useAtomValue: () => null };
+});
+
+const base: WidgetLoadDiagnosticsInput = {
+  enabled: true,
+  loadId: 'load-1',
+  widgetType: WidgetTypeV3.ProductCardV3,
+  widgetConfigId: 'cfg-1',
+  startLoading: false,
+  ownRequestsSettled: false,
+  hardcopyContent: undefined,
+  visibilitySource: 'observer',
+  pendingRequests: ['hardcopy'],
+  hardcopyErrorReason: undefined,
+};
+
+// Pull the eventProps of the diagnostics call whose `type` matches.
+const propsOfType = (type: string): Record<string, unknown> | undefined =>
+  trackEvent.mock.calls
+    .map((c: [{ eventProps: Record<string, unknown> }]) => c[0].eventProps)
+    .find((p: Record<string, unknown>) => p.type === type);
+
+beforeEach(() => {
+  trackEvent.mockClear();
+});
+
+describe('useWidgetLoadDiagnostics', () => {
+  it('emits nothing while disabled', () => {
+    renderHook(() => useWidgetLoadDiagnostics({ ...base, enabled: false, startLoading: true }));
+    expect(trackEvent).not.toHaveBeenCalled();
+  });
+
+  it('emits widget_mounted on mount regardless of visibility (the ungated baseline)', () => {
+    renderHook(() => useWidgetLoadDiagnostics({ ...base, startLoading: false }));
+    const mounted = propsOfType('widget_mounted');
+    expect(mounted).toBeDefined();
+    expect(mounted).toMatchObject({ load_id: 'load-1', widget_type: WidgetTypeV3.ProductCardV3 });
+    // No outcome/stall — it never became visible.
+    expect(propsOfType('widget_load_outcome')).toBeUndefined();
+  });
+
+  it('emits content_loaded when own requests settle with live api content', () => {
+    const { rerender } = renderHook(props => useWidgetLoadDiagnostics(props), {
+      initialProps: { ...base, startLoading: true },
+    });
+    rerender({
+      ...base,
+      startLoading: true,
+      ownRequestsSettled: true,
+      hardcopyContent: { responseId: 'r', language: 'en', values: {}, servedFrom: 'api' },
+      pendingRequests: [],
+    });
+    const outcome = propsOfType('widget_load_outcome');
+    expect(outcome).toMatchObject({ outcome: 'content_loaded', visibility_source: 'observer' });
+  });
+
+  it('emits static_fallback with the fallback reason', () => {
+    const { rerender } = renderHook(props => useWidgetLoadDiagnostics(props), {
+      initialProps: { ...base, startLoading: true },
+    });
+    rerender({
+      ...base,
+      startLoading: true,
+      ownRequestsSettled: true,
+      hardcopyContent: {
+        responseId: 'r',
+        language: 'en',
+        values: {},
+        servedFrom: 'static',
+        fallbackReason: 'timeout',
+      },
+    });
+    expect(propsOfType('widget_load_outcome')).toMatchObject({
+      outcome: 'static_fallback',
+      reason: 'timeout',
+    });
+  });
+
+  it('emits error when the load settles without content', () => {
+    const { rerender } = renderHook(props => useWidgetLoadDiagnostics(props), {
+      initialProps: { ...base, startLoading: true },
+    });
+    rerender({
+      ...base,
+      startLoading: true,
+      ownRequestsSettled: true,
+      hardcopyContent: undefined,
+      hardcopyErrorReason: 'hardcopy_error',
+    });
+    expect(propsOfType('widget_load_outcome')).toMatchObject({
+      outcome: 'error',
+      reason: 'hardcopy_error',
+    });
+  });
+
+  it('carries visibility_source=fallback through the outcome', () => {
+    const { rerender } = renderHook(props => useWidgetLoadDiagnostics(props), {
+      initialProps: { ...base, startLoading: true, visibilitySource: 'fallback' as const },
+    });
+    rerender({
+      ...base,
+      startLoading: true,
+      visibilitySource: 'fallback',
+      ownRequestsSettled: true,
+      hardcopyContent: { responseId: 'r', language: 'en', values: {}, servedFrom: 'api' },
+    });
+    expect(propsOfType('widget_load_outcome')).toMatchObject({ visibility_source: 'fallback' });
+  });
+
+  describe('stall (abandonment-safe)', () => {
+    beforeEach(() => vi.useFakeTimers());
+    afterEach(() => vi.useRealTimers());
+
+    it('emits widget_load_stalled if still loading at the threshold', () => {
+      renderHook(() => useWidgetLoadDiagnostics({ ...base, startLoading: true }));
+      act(() => {
+        vi.advanceTimersByTime(WIDGET_LOAD_STALL_MS);
+      });
+      expect(propsOfType('widget_load_stalled')).toMatchObject({ pending_requests: ['hardcopy'] });
+    });
+
+    it('does NOT emit a stall when the widget unmounts first (navigated away)', () => {
+      const { unmount } = renderHook(() =>
+        useWidgetLoadDiagnostics({ ...base, startLoading: true }),
+      );
+      unmount();
+      act(() => {
+        vi.advanceTimersByTime(WIDGET_LOAD_STALL_MS * 2);
+      });
+      expect(propsOfType('widget_load_stalled')).toBeUndefined();
+    });
+
+    it('does NOT emit a stall once the load has settled', () => {
+      const { rerender } = renderHook(props => useWidgetLoadDiagnostics(props), {
+        initialProps: { ...base, startLoading: true },
+      });
+      rerender({ ...base, startLoading: true, ownRequestsSettled: true });
+      act(() => {
+        vi.advanceTimersByTime(WIDGET_LOAD_STALL_MS * 2);
+      });
+      expect(propsOfType('widget_load_stalled')).toBeUndefined();
+    });
+  });
+});

package/src/hooks/WidgetLoadDiagnostics/index.ts

@@ -0,0 +1,5 @@
+export { useWidgetLoadDiagnostics, WIDGET_LOAD_STALL_MS } from './useWidgetLoadDiagnostics';
+export type {
+  WidgetLoadDiagnosticsInput,
+  WidgetVisibilitySource,
+} from './useWidgetLoadDiagnostics';

package/src/hooks/WidgetLoadDiagnostics/useWidgetLoadDiagnostics.ts

@@ -0,0 +1,178 @@
+import { useAtomValue } from 'jotai';
+import { useEffect, useRef } from 'react';
+import { pageVariantInfoAtom } from 'src/atoms/app';
+import { useAmplitude } from 'src/contexts/amplitudeContext/amplitudeContext';
+import { HardcopyResponse } from 'src/contexts/hardcopyContext';
+import { PageVariantInfo } from 'src/contexts/pageContext/types';
+import { WidgetTypeV3 } from 'src/contexts/typesV3';
+import { extractPageContext } from 'src/hooks/WidgetInteraction/utils';
+import { EnviveMetricsEventName } from 'src/services/amplitudeService/amplitudeService';
+
+// Fired if a widget is still loading this long after it became visible. Kept at/just above
+// the hardcopy timeout (HARDCOPY_TIMEOUT_MS, 4s) so a normal timeout → static-fallback settles
+// first and does NOT trip a stall; a stall here is a genuine anomaly (e.g. a config hang).
+// Mirrors WIDGET_LOADING_WATCHDOG_MS (the console-only watchdog in withBaseWidget).
+export const WIDGET_LOAD_STALL_MS = 5000;
+
+// 'pending' = visibility not confirmed by either path when the event fired (e.g. a
+// deferLoading:false widget that loaded eagerly, before the observer reported).
+export type WidgetVisibilitySource = 'observer' | 'fallback' | 'pending';
+
+export interface WidgetLoadDiagnosticsInput {
+  /** Gate. No events are emitted unless true. On by default; a Statsig kill switch can disable it. */
+  enabled: boolean;
+  /** Correlates this widget's mount / rendered / outcome / stall events for a single load. */
+  loadId: string;
+  widgetType: WidgetTypeV3;
+  widgetConfigId?: string;
+  /** The widget became visible and started loading its own requests. */
+  startLoading: boolean;
+  /** This widget's own hardcopy / widgetConfig / uiConfig requests have all settled. */
+  ownRequestsSettled: boolean;
+  /** Present once hardcopy resolves; carries `servedFrom` (content_loaded vs static_fallback). */
+  hardcopyContent?: HardcopyResponse;
+  /** Whether visibility came from the observer or the reconcile fallback. */
+  visibilitySource: WidgetVisibilitySource;
+  /** Names of this widget's still-unsettled requests, reported on a stall. */
+  pendingRequests: string[];
+  /** Set when this widget's own hardcopy request rejected (no content — not a static fallback). */
+  hardcopyErrorReason?: string;
+}
+
+const connectionType = (): string | undefined => {
+  try {
+    // Network Information API — Chromium/Android only, undefined on iOS Safari (our key population).
+    return (navigator as Navigator & { connection?: { effectiveType?: string } }).connection
+      ?.effectiveType;
+  } catch {
+    return undefined;
+  }
+};
+
+const now = (): number => {
+  try {
+    return typeof window !== 'undefined' && window.performance?.now
+      ? window.performance.now()
+      : Date.now();
+  } catch {
+    return Date.now();
+  }
+};
+
+/**
+ * Emits the layered `[Envive] Diagnostics` widget-load net so eng can measure not just what
+ * loads, but the negative space between layers — the failures that fire nothing today:
+ *
+ *   widget_mounted (ungated) → [Envive] Widget Rendered (visible) → widget_load_outcome
+ *
+ * - `widget_mounted` fires on mount regardless of visibility, so a widget that mounts but never
+ *   becomes visible (the suspected infinite-load crux) shows up as a *mounted with no rendered*
+ *   gap instead of being invisible to analytics entirely.
+ * - `widget_load_outcome` fires once the widget's own requests settle
+ *   (content_loaded / static_fallback / error).
+ * - `widget_load_stalled` fires if it's still loading at WIDGET_LOAD_STALL_MS AND still mounted.
+ *   The timer is cleared on unmount, so a shopper who navigates away first never trips it —
+ *   "stalled with no later outcome" is therefore a clean stuck signal, undiluted by abandonment.
+ *
+ * `load_id` correlates all of the above (and is threaded onto `[Envive] Widget Rendered`) so
+ * the gaps are joinable per load.
+ */
+export const useWidgetLoadDiagnostics = (input: WidgetLoadDiagnosticsInput): void => {
+  const {
+    enabled,
+    loadId,
+    widgetType,
+    widgetConfigId,
+    startLoading,
+    ownRequestsSettled,
+    hardcopyContent,
+  } = input;
+
+  const { trackEvent } = useAmplitude();
+  const variantInfo = useAtomValue(pageVariantInfoAtom);
+
+  // Latest input, read inside the deferred stall/outcome callbacks (pendingRequests and
+  // visibilitySource churn as requests settle / the fallback engages).
+  const inputRef = useRef(input);
+  inputRef.current = input;
+
+  const emit = (props: Record<string, unknown>) => {
+    trackEvent({
+      eventName: EnviveMetricsEventName.Diagnostics,
+      eventProps: {
+        load_id: loadId,
+        widget_type: widgetType,
+        widget_config_id: widgetConfigId,
+        connection_type: connectionType(),
+        context: variantInfo ? extractPageContext(variantInfo as PageVariantInfo) : null,
+        ...props,
+      },
+    });
+  };
+
+  // Layer 0 — mount. Ungated by visibility: the baseline that fires even when the widget never
+  // becomes visible, so never-visible failures are a measurable gap rather than silence.
+  const mountFiredRef = useRef(false);
+  useEffect(() => {
+    if (!enabled || mountFiredRef.current) return;
+    mountFiredRef.current = true;
+    emit({ type: 'widget_mounted' });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [enabled]);
+
+  // t0 — when the widget became visible / started loading.
+  const visibleAtRef = useRef<number | null>(null);
+  useEffect(() => {
+    if (startLoading && visibleAtRef.current === null) visibleAtRef.current = now();
+  }, [startLoading]);
+
+  // Layer 2 — terminal outcome, once, when this widget's own requests settle.
+  const outcomeFiredRef = useRef(false);
+  useEffect(() => {
+    if (!enabled || !startLoading || !ownRequestsSettled || outcomeFiredRef.current) return;
+    outcomeFiredRef.current = true;
+
+    const elapsed_ms =
+      visibleAtRef.current !== null ? Math.round(now() - visibleAtRef.current) : undefined;
+
+    let outcome: string;
+    let reason: string | undefined;
+    if (!hardcopyContent) {
+      outcome = 'error';
+      reason = inputRef.current.hardcopyErrorReason ?? 'no_content';
+    } else if (hardcopyContent.servedFrom === 'static') {
+      outcome = 'static_fallback';
+      reason = hardcopyContent.fallbackReason;
+    } else {
+      outcome = 'content_loaded';
+    }
+
+    emit({
+      type: 'widget_load_outcome',
+      outcome,
+      reason,
+      elapsed_ms,
+      visibility_source: inputRef.current.visibilitySource,
+    });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [enabled, startLoading, ownRequestsSettled, hardcopyContent]);
+
+  // Layer 1.5 — stall. Only arms while loading; cleared on unmount, so abandonment never trips it.
+  useEffect(() => {
+    if (!enabled || !startLoading || ownRequestsSettled) return undefined;
+    const timer = setTimeout(() => {
+      const elapsed_ms =
+        visibleAtRef.current !== null
+          ? Math.round(now() - visibleAtRef.current)
+          : WIDGET_LOAD_STALL_MS;
+      emit({
+        type: 'widget_load_stalled',
+        elapsed_ms,
+        pending_requests: inputRef.current.pendingRequests,
+        visibility_source: inputRef.current.visibilitySource,
+      });
+    }, WIDGET_LOAD_STALL_MS);
+    return () => clearTimeout(timer);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [enabled, startLoading, ownRequestsSettled]);
+};

package/src/services/amplitudeService/eventNames.ts

@@ -48,4 +48,8 @@ export enum EnviveMetricsEventName {
   WidgetTextRequest = 'Widget Text Request',
   WidgetTextResponse = 'Widget Text Response',
   WidgetTextClicked = 'Widget Text Clicked',
+  // Operational diagnostics for widget loading (see useWidgetLoadDiagnostics). A single event
+  // with a `type` discriminator (widget_mounted | widget_load_outcome | widget_load_stalled)
+  // so eng can measure the layered load net and, crucially, the negative space between layers.
+  Diagnostics = 'Diagnostics',
 }

package/src/services/enviveConfigService/__tests__/enviveConfigService.test.ts

@@ -30,6 +30,76 @@ function makeOkConfigFetch() {
   });
 }
 
+// getWidgetConfig response with the use_unified_config gate ON (plus a real
+// version pin) — the trigger for the /v1/session/bootstrap upgrade.
+function makeGateOnConfigFetch() {
+  mockFetch.mockResolvedValueOnce({
+    ok: true,
+    json: () =>
+      Promise.resolve({
+        data: {
+          me: {
+            org: {
+              id: 'org-1',
+              shortName: 'test-org',
+              displayName: 'Test Org',
+              domain: 'test.com',
+              createdAt: '2024-01-01T00:00:00.000Z',
+              updatedAt: '2024-01-01T00:00:00.000Z',
+            },
+            getWidgetConfig: {
+              productsConfig: {},
+              gates: [{ name: 'use_unified_config', value: true }],
+              experimentAssignments: [],
+              resolution: { baseVersion: '1.0.0', baseVersionSource: 'merchant_layer' },
+            },
+          },
+        },
+      }),
+  });
+}
+
+// /v1/session/bootstrap response (REST snake_case). Distinct org id so tests can
+// assert the config actually came from bootstrap, not the getWidgetConfig call.
+function makeBootstrapFetch() {
+  mockFetch.mockResolvedValueOnce({
+    ok: true,
+    json: () =>
+      Promise.resolve({
+        org_config: {
+          org: {
+            org: {
+              id: 'org-boot',
+              short_name: 'boot-org',
+              display_name: 'Boot Org',
+              domain: 'boot.com',
+              status: 'active',
+              created_at: '2024-01-01T00:00:00.000Z',
+              updated_at: '2024-01-01T00:00:00.000Z',
+            },
+            settings: {},
+          },
+          gates: [{ name: 'use_unified_config', value: true, group_name: 'Treatment' }],
+          resolution: { base_version: '1.0.0', base_version_source: 'merchant_layer' },
+        },
+        widget_config: {
+          products_config: {},
+          // Assignments come from widget_config (matches getWidgetConfig, ungated).
+          experiment_assignments: [
+            {
+              layer_name: 'ml',
+              namespace: 'ml',
+              allocated_experiment_name: 'exp_a',
+              group_name: 'A',
+            },
+          ],
+          resolution: { base_version: '1.0.0', base_version_source: 'merchant_layer' },
+        },
+        url_resolving: { variant_type: 'pdp', specific_details: {}, ready: true },
+      }),
+  });
+}
+
 function makeService(
   overrides: Partial<ConstructorParameters<typeof EnviveConfigService>[0]> = {},
 ) {
@@ -182,3 +252,159 @@ describe('EnviveConfigService caching', () => {
     expect(result.org.org.id).toBe('org-1');
   });
 });
+
+describe('EnviveConfigService bootstrap upgrade (use_unified_config)', () => {
+  // The injection bundle supplies env + contextSource; without them the branch
+  // is skipped entirely (see the "non-bundle caller" case below).
+  const bootstrapService = () => makeService({ env: 'dev', contextSource: 'app' });
+
+  it('stays on getWidgetConfig (no bootstrap) when the gate is off', async () => {
+    makeOkConfigFetch(); // gates: []
+
+    const service = bootstrapService();
+    const result = await service.getEnviveConfig();
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(mockFetch.mock.calls[0][0]).toContain('/v1/graphql');
+    expect(result.org.org.id).toBe('org-1');
+    expect(service.takeBootstrapUrlResolving()).toBeNull();
+  });
+
+  it('calls /v1/session/bootstrap and uses ITS config when the gate is on', async () => {
+    makeGateOnConfigFetch();
+    makeBootstrapFetch();
+
+    const service = bootstrapService();
+    const result = await service.getEnviveConfig();
+
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+    expect(mockFetch.mock.calls[1][0]).toContain('/v1/session/bootstrap');
+    // config is bootstrap's, not the getWidgetConfig call used to read the gate.
+    expect(result.org.org.id).toBe('org-boot');
+    expect(result.org.org.short_name).toBe('boot-org');
+    // gates: snake group_name mapped to camel groupName.
+    expect(result.gates).toContainEqual({
+      name: 'use_unified_config',
+      value: true,
+      groupName: 'Treatment',
+    });
+    // experiment_assignments pass through (already snake).
+    expect(result.experiment_assignments).toEqual([
+      { layer_name: 'ml', namespace: 'ml', allocated_experiment_name: 'exp_a', group_name: 'A' },
+    ]);
+    // resolution mapped snake -> camel.
+    expect(result.orgConfig?.resolution).toEqual({
+      baseVersion: '1.0.0',
+      baseVersionSource: 'merchant_layer',
+    });
+  });
+
+  it('stashes bootstrap url_resolving (paired with its URL) for the warm-up to consume once', async () => {
+    makeGateOnConfigFetch();
+    makeBootstrapFetch();
+
+    const service = bootstrapService();
+    await service.getEnviveConfig();
+
+    const taken = service.takeBootstrapUrlResolving();
+    expect(taken?.response).toEqual({ variant_type: 'pdp', specific_details: {}, ready: true });
+    // paired with the URL bootstrap resolved (the current, cleansed href) so the
+    // warm-up can guard against a SPA nav before seeding.
+    expect(taken?.url).toBe(window.location.href.toLowerCase().trim());
+    // handed off exactly once.
+    expect(service.takeBootstrapUrlResolving()).toBeNull();
+  });
+
+  it('sends url_resolving context + gate names + version pin in the bootstrap body', async () => {
+    makeGateOnConfigFetch();
+    makeBootstrapFetch();
+
+    await bootstrapService().getEnviveConfig();
+
+    const [, options] = mockFetch.mock.calls[1];
+    const body = JSON.parse(options.body as string);
+    expect(body.include_feature_gates).toContain('use_unified_config');
+    // Scopes org_config.configs so bootstrap doesn't dump internal configs to the browser.
+    expect(body.namespace).toBe('spiffy-react-components');
+    expect(body.url_resolving.context).toMatchObject({
+      org_id: 'org-1',
+      org_short_name: 'test-org',
+      source: 'app',
+      env: 'dev',
+    });
+    // The version comes ONLY from the URL query param (none set here) — never from
+    // getWidgetConfig's resolution, so bootstrap doesn't depend on the discarded
+    // getWidgetConfig response.
+    expect(body.url_resolving.org_base_config_version).toBeUndefined();
+    expect(body.url_resolving.override_config_version).toBeUndefined();
+    // override-aware gates (FeatureFlagService.getFeatureFlags()) forwarded so
+    // client gate overrides reach page-variant resolution.
+    expect(body.url_resolving.feature_gates.use_unified_config).toBe(true);
+    // the persistent chat session id is threaded (not an empty string).
+    expect(body.url_resolving.context.chat_id).toBeTruthy();
+  });
+
+  it('reflects a ?<gate>=true override in the bootstrap feature_gates it sends', async () => {
+    // Force a page-variant gate the server did NOT return — it must still reach
+    // bootstrap's url_resolving via getFeatureFlags()'s override precedence.
+    window.history.replaceState({}, '', '/?use_unified_config=true&is_empty_div_plp_enabled=true');
+    makeOkConfigFetch(); // gates: [] — the ?use_unified_config=true override drives the bootstrap path
+    makeBootstrapFetch();
+
+    await bootstrapService().getEnviveConfig();
+
+    const body = JSON.parse(mockFetch.mock.calls[1][1].body as string);
+    expect(body.url_resolving.feature_gates.is_empty_div_plp_enabled).toBe(true);
+  });
+
+  it('skips bootstrap for non-bundle callers (no env/contextSource) even when the gate is on', async () => {
+    makeGateOnConfigFetch();
+
+    const result = await makeService().getEnviveConfig(); // no env/contextSource
+
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(result.org.org.id).toBe('org-1');
+  });
+
+  it('falls back to the getWidgetConfig config when bootstrap fails', async () => {
+    makeGateOnConfigFetch();
+    mockFetch.mockResolvedValueOnce({ ok: false, statusText: 'Bad Gateway' });
+
+    const service = bootstrapService();
+    const result = await service.getEnviveConfig();
+
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+    // degraded to the proven path rather than aborting.
+    expect(result.org.org.id).toBe('org-1');
+    expect(service.takeBootstrapUrlResolving()).toBeNull();
+  });
+
+  it('falls back to getWidgetConfig config when bootstrap returns a malformed 2xx payload', async () => {
+    makeGateOnConfigFetch();
+    // 2xx but missing required sections — must NOT replace the known-good config
+    // with empty gates / mock products (which would disable the client session).
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: () => Promise.resolve({ org_config: {}, widget_config: null }),
+    });
+
+    const service = bootstrapService();
+    const result = await service.getEnviveConfig();
+
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+    expect(result.org.org.id).toBe('org-1'); // getWidgetConfig's, not bootstrap's empty payload
+    expect(service.takeBootstrapUrlResolving()).toBeNull();
+  });
+
+  it('honors a ?use_unified_config=true override when the gate itself is off', async () => {
+    window.history.replaceState({}, '', '/?use_unified_config=true');
+    makeOkConfigFetch(); // gates: [] — the override, not the gate, forces bootstrap
+    makeBootstrapFetch();
+
+    const result = await bootstrapService().getEnviveConfig();
+
+    expect(mockFetch).toHaveBeenCalledTimes(2);
+    expect(mockFetch.mock.calls[1][0]).toContain('/v1/session/bootstrap');
+    expect(result.org.org.id).toBe('org-boot');
+  });
+});