@envive-ai/react-hooks 0.3.63 → 0.3.65

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

@@ -3,65 +3,15 @@ import { EnviveConfigService } from '../enviveConfigService';
 const mockFetch = vi.fn();
 globalThis.fetch = mockFetch;
 
-// getWidgetConfig is the single config call now: it returns org identity +
-// gates + experiment assignments alongside productsConfig (the separate
-// GET /v1/org/config fetch was removed). productsConfig has no colors, so
-// fetchUnifiedGraphQLConfig falls back to its mock config — fine here since
-// these tests only care about caching / fetch-count behaviour.
-function makeOkConfigFetch() {
-  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: [], experimentAssignments: [] },
-          },
-        },
-      }),
-  });
-}
-
-// 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() {
+// /v1/session/bootstrap is the single session-config call now (getWidgetConfig
+// and the separate GET /v1/org/config were removed). A valid response carries
+// org identity + a NON-EMPTY gates array (the malformed-payload guard requires
+// it) + widget_config. orgId is parameterised so cache tests can assert the
+// config actually came back; urlResolving is null-able for the config-only path.
+function makeBootstrapFetch(
+  orgId = 'org-1',
+  urlResolving: unknown = { variant_type: 'pdp', specific_details: {}, ready: true },
+) {
   mockFetch.mockResolvedValueOnce({
     ok: true,
     json: () =>
@@ -69,10 +19,10 @@ function makeBootstrapFetch() {
         org_config: {
           org: {
             org: {
-              id: 'org-boot',
-              short_name: 'boot-org',
-              display_name: 'Boot Org',
-              domain: 'boot.com',
+              id: orgId,
+              short_name: 'test-org',
+              display_name: 'Test Org',
+              domain: 'test.com',
               status: 'active',
               created_at: '2024-01-01T00:00:00.000Z',
               updated_at: '2024-01-01T00:00:00.000Z',
@@ -84,7 +34,7 @@ function makeBootstrapFetch() {
         },
         widget_config: {
           products_config: {},
-          // Assignments come from widget_config (matches getWidgetConfig, ungated).
+          // Assignments come from widget_config (ungated).
           experiment_assignments: [
             {
               layer_name: 'ml',
@@ -95,7 +45,7 @@ function makeBootstrapFetch() {
           ],
           resolution: { base_version: '1.0.0', base_version_source: 'merchant_layer' },
         },
-        url_resolving: { variant_type: 'pdp', specific_details: {}, ready: true },
+        url_resolving: urlResolving,
       }),
   });
 }
@@ -125,17 +75,18 @@ afterEach(() => {
 });
 
 describe('EnviveConfigService caching', () => {
-  it('fetches the unified config once on a cold cache', async () => {
-    makeOkConfigFetch();
+  it('fetches the session config once on a cold cache', async () => {
+    makeBootstrapFetch();
 
     const result = await makeService().getEnviveConfig();
 
     expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(mockFetch.mock.calls[0][0]).toContain('/v1/session/bootstrap');
     expect(result.org.org.id).toBe('org-1');
   });
 
   it('serves a warm cache to a new instance with identical params without hitting the network', async () => {
-    makeOkConfigFetch();
+    makeBootstrapFetch();
     await makeService().getEnviveConfig();
     expect(mockFetch).toHaveBeenCalledTimes(1);
 
@@ -151,13 +102,13 @@ describe('EnviveConfigService caching', () => {
     vi.useFakeTimers();
     vi.setSystemTime(new Date('2026-01-01T00:00:00.000Z'));
 
-    makeOkConfigFetch();
+    makeBootstrapFetch();
     await makeService().getEnviveConfig();
     expect(mockFetch).toHaveBeenCalledTimes(1);
 
     vi.setSystemTime(new Date('2026-01-01T00:05:01.000Z'));
 
-    makeOkConfigFetch();
+    makeBootstrapFetch();
     await makeService().getEnviveConfig();
 
     expect(mockFetch).toHaveBeenCalledTimes(2);
@@ -168,11 +119,11 @@ describe('EnviveConfigService caching', () => {
     async param => {
       window.history.replaceState({}, '', `/?${param}=1.2.3`);
 
-      makeOkConfigFetch();
+      makeBootstrapFetch();
       await makeService().getEnviveConfig();
       expect(mockFetch).toHaveBeenCalledTimes(1);
 
-      makeOkConfigFetch();
+      makeBootstrapFetch();
       await makeService().getEnviveConfig();
 
       // No cache read/write happened, so a second instance refetches instead
@@ -183,33 +134,33 @@ describe('EnviveConfigService caching', () => {
 
   it('does not read a version-pinned cache entry after the override is removed', async () => {
     window.history.replaceState({}, '', '/?envive_config_version=1.2.3');
-    makeOkConfigFetch();
+    makeBootstrapFetch();
     await makeService().getEnviveConfig();
 
     window.history.replaceState({}, '', '/');
-    makeOkConfigFetch();
+    makeBootstrapFetch();
     await makeService().getEnviveConfig();
 
     expect(mockFetch).toHaveBeenCalledTimes(2);
   });
 
   it('keeps separate cache entries per userId', async () => {
-    makeOkConfigFetch();
+    makeBootstrapFetch();
     await makeService({ userId: 'user-1' }).getEnviveConfig();
     expect(mockFetch).toHaveBeenCalledTimes(1);
 
-    makeOkConfigFetch();
+    makeBootstrapFetch();
     await makeService({ userId: 'user-2' }).getEnviveConfig();
 
     expect(mockFetch).toHaveBeenCalledTimes(2);
   });
 
   it('keeps separate cache entries per namespace/source/baseUrl/apiKey', async () => {
-    makeOkConfigFetch();
+    makeBootstrapFetch();
     await makeService({ namespace: 'ns-a' }).getEnviveConfig();
     expect(mockFetch).toHaveBeenCalledTimes(1);
 
-    makeOkConfigFetch();
+    makeBootstrapFetch();
     await makeService({ namespace: 'ns-b' }).getEnviveConfig();
 
     expect(mockFetch).toHaveBeenCalledTimes(2);
@@ -220,7 +171,7 @@ describe('EnviveConfigService caching', () => {
       throw new Error('quota exceeded');
     });
 
-    makeOkConfigFetch();
+    makeBootstrapFetch();
 
     const result = await makeService().getEnviveConfig();
 
@@ -232,7 +183,7 @@ describe('EnviveConfigService caching', () => {
       throw new Error('storage disabled');
     });
 
-    makeOkConfigFetch();
+    makeBootstrapFetch();
 
     const result = await makeService().getEnviveConfig();
 
@@ -241,47 +192,34 @@ describe('EnviveConfigService caching', () => {
 
   it('fails open and refetches when a cached entry is corrupted JSON', async () => {
     const service = makeService();
-    makeOkConfigFetch();
+    makeBootstrapFetch();
     await service.getEnviveConfig();
     const [key] = Object.keys(sessionStorage);
     sessionStorage.setItem(key, 'not json');
 
-    makeOkConfigFetch();
+    makeBootstrapFetch();
     const result = await makeService().getEnviveConfig();
 
     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).
+describe('EnviveConfigService bootstrap request', () => {
+  // The injection bundle supplies env + contextSource, which request bootstrap's
+  // url_resolving branch. Without them the branch is omitted (see the config-only
+  // case below), but bootstrap is still the config call either way.
   const bootstrapService = () => makeService({ env: 'dev', contextSource: 'app' });
 
-  it('stays on getWidgetConfig (no bootstrap) when the gate is off', async () => {
-    makeOkConfigFetch(); // gates: []
+  it('issues a single /v1/session/bootstrap call and returns its config', async () => {
+    makeBootstrapFetch('org-boot');
 
     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(mockFetch.mock.calls[0][0]).toContain('/v1/session/bootstrap');
     expect(result.org.org.id).toBe('org-boot');
-    expect(result.org.org.short_name).toBe('boot-org');
+    expect(result.org.org.short_name).toBe('test-org');
     // gates: snake group_name mapped to camel groupName.
     expect(result.gates).toContainEqual({
       name: 'use_unified_config',
@@ -300,7 +238,6 @@ describe('EnviveConfigService bootstrap upgrade (use_unified_config)', () => {
   });
 
   it('stashes bootstrap url_resolving (paired with its URL) for the warm-up to consume once', async () => {
-    makeGateOnConfigFetch();
     makeBootstrapFetch();
 
     const service = bootstrapService();
@@ -315,96 +252,73 @@ describe('EnviveConfigService bootstrap upgrade (use_unified_config)', () => {
     expect(service.takeBootstrapUrlResolving()).toBeNull();
   });
 
-  it('sends url_resolving context + gate names + version pin in the bootstrap body', async () => {
-    makeGateOnConfigFetch();
+  it('sends the url_resolving context (no org identity), gate names, and namespace in the body', async () => {
     makeBootstrapFetch();
 
     await bootstrapService().getEnviveConfig();
 
-    const [, options] = mockFetch.mock.calls[1];
+    const [, options] = mockFetch.mock.calls[0];
     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.
+    // org identity is NOT sent — the server fills it from the authenticated org.
+    expect(body.url_resolving.context).toMatchObject({ source: 'app', env: 'dev' });
+    expect(body.url_resolving.context.org_id).toBeUndefined();
+    expect(body.url_resolving.context.org_short_name).toBeUndefined();
+    // No config-version override set here.
     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);
+    // No client gate overrides set → empty map (server resolves the real gates).
+    expect(body.url_resolving.feature_gates).toEqual({});
     // 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.
+  it('forwards ?<gate>=true overrides in the bootstrap feature_gates it sends', async () => {
+    // Client overrides (query param) must reach bootstrap's url_resolving so they
+    // still drive page-variant selection; the server merges them over its gates.
     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);
+    const body = JSON.parse(mockFetch.mock.calls[0][1].body as string);
+    expect(body.url_resolving.feature_gates.use_unified_config).toBe(true);
     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();
+  it('omits the url_resolving branch for non-bundle callers (no env/contextSource) but still fetches config', async () => {
+    makeBootstrapFetch('org-1', null);
 
-    const result = await makeService().getEnviveConfig(); // no env/contextSource
+    const service = makeService(); // no env/contextSource
+    const result = await service.getEnviveConfig();
 
     expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(mockFetch.mock.calls[0][0]).toContain('/v1/session/bootstrap');
+    const body = JSON.parse(mockFetch.mock.calls[0][1].body as string);
+    expect(body.url_resolving).toBeUndefined();
     expect(result.org.org.id).toBe('org-1');
+    expect(service.takeBootstrapUrlResolving()).toBeNull();
   });
 
-  it('falls back to the getWidgetConfig config when bootstrap fails', async () => {
-    makeGateOnConfigFetch();
+  it('throws (aborting injection) when bootstrap fails — there is no getWidgetConfig fallback', async () => {
     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();
+    await expect(bootstrapService().getEnviveConfig()).rejects.toThrow(
+      'Bootstrap config request failed',
+    );
   });
 
-  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).
+  it('throws when bootstrap returns a malformed 2xx payload', async () => {
+    // 2xx but missing required sections — must NOT become a config with empty
+    // gates / mock products (which would disable the client session). No fallback
+    // left, so the throw propagates and injection aborts.
     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');
+    await expect(bootstrapService().getEnviveConfig()).rejects.toThrow('missing required sections');
   });
 });