@envive-ai/react-hooks 0.3.63 → 0.3.64

package/dist/services/hardcopyService/hardcopyService.js

@@ -203,6 +203,7 @@ var HardcopyService = class {
 				request_id: widgetTextRequest.requestId
 			}
 		});
+		let fallbackReason;
 		try {
 			const response = await withTimeout(commerce_api_default.getHardcopy(widgetTextRequest), HARDCOPY_TIMEOUT_MS);
 			if (response) {
@@ -218,15 +219,23 @@ var HardcopyService = class {
 						...response.aiSuggestionsAttributionBySlot ? { ai_suggestions_attribution_by_slot: response.aiSuggestionsAttributionBySlot } : {}
 					}
 				});
-				return convertedResponse;
+				return {
+					...convertedResponse,
+					servedFrom: "api"
+				};
 			}
 		} catch (error) {
 			logger.logError("error getting hardcopy from backend", error);
+			fallbackReason = error instanceof Error && error.message.includes("timed out") ? "timeout" : "error";
 		}
 		const mockResponse = MOCK_HARDCOPY_RESPONSE[request.widgetType];
 		if (mockResponse) {
 			logger.logDebug("no real response, using mock", mockResponse);
-			return mockResponse;
+			return {
+				...mockResponse,
+				servedFrom: "static",
+				fallbackReason: fallbackReason ?? "error"
+			};
 		}
 		throw new Error(`No hardcopy response found for widget type: ${request.widgetType}`);
 	}
@@ -245,4 +254,4 @@ var MockHardcopyService = class {
 
 //#endregion
 export { HARDCOPY_TIMEOUT_MS, HardcopyService, MOCK_HARDCOPY_RESPONSE, MockHardcopyService };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"hardcopyService.js","names":["Logger","timer: ReturnType<typeof setTimeout>","MOCK_HARDCOPY_RESPONSE: Partial<Record<WidgetTypeV3, HardcopyResponse>>","uuid","config: HardcopyServiceConfig","widgetTextRequest: WidgetTextRequest","wireWidgetType: string","CommerceApiClient","overrides: Partial<Record<WidgetTypeV3, HardcopyResponse>>"],"sources":["../../../src/services/hardcopyService/hardcopyService.ts"],"sourcesContent":["import { v4 as uuid } from 'uuid';\nimport CommerceApiClient from 'src/application/commerce-api';\nimport { WidgetString, WidgetText } from 'src/application/models/api/widgetText';\nimport { WidgetTextRequest } from 'src/application/models/api/widgetTextRequest';\nimport { toCamelCase } from 'src/application/models/utils/snakeToCamelTransformer';\nimport { getQueryParam } from 'src/application/utils';\nimport { coreWidgetTypeToApiWidgetType } from 'src/application/utils/widgetTextRequestToApiRequest';\nimport { UserEvent } from 'src/application/models';\nimport Logger from 'src/application/logging/logger';\nimport { AppDetails } from 'src/atoms/app';\nimport { getAtomStore } from 'src/atoms/atomStore/atomStore';\nimport { resolvedBaseConfigVersionAtom } from 'src/atoms/envive/resolvedBaseConfigVersion';\nimport { WidgetTypeV3 } from 'src/contexts/typesV3';\nimport { EnviveMetricsEventName, TrackEventParams } from '../amplitudeService';\n\nconst logger = new Logger('hardcopyService');\n\n// Longest a hardcopy request may hang before we stop waiting for it. The backend-error\n// path below already falls back to static copy, but a request that never settles at all\n// never reaches that catch — it left the widget's loading latch unresolved forever, which\n// is the \"PLP staying in loading state\" failure. Racing the request against this timeout\n// turns a hang into the same fallback path an error takes, so the widget always leaves its\n// loading state.\n//\n// Kept under the ~4-5s at which session replays show shoppers abandon a still-loading\n// widget: a rescue that fires after they've left helps no one. When it fires, the catch\n// below logs an error (message includes \"timed out\") — that log is the signal monitoring\n// can count to measure how often hardcopy stalls.\nexport const HARDCOPY_TIMEOUT_MS = 4000;\n\n// Reject if `promise` has not settled within `ms`. The underlying request is not aborted\n// (a late response is simply discarded) — the only goal is to stop *waiting*, so the\n// caller's error handling can run.\nconst withTimeout = <T>(promise: Promise<T>, ms: number): Promise<T> => {\n  let timer: ReturnType<typeof setTimeout>;\n  const timeout = new Promise<never>((_, reject) => {\n    timer = setTimeout(() => reject(new Error(`hardcopy request timed out after ${ms}ms`)), ms);\n  });\n  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer)) as Promise<T>;\n};\n\nexport interface HardcopyRequest {\n  widgetType: WidgetTypeV3;\n  userEvent: UserEvent;\n}\n\nexport type HardcopyResponse = {\n  responseId: string;\n  language: string;\n  rawValues?: Record<string, WidgetString | WidgetString[]>;\n  values: Record<string, string | string[]>;\n};\n\nexport interface IHardcopyService {\n  getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse>;\n}\n\nexport interface HardcopyServiceConfig {\n  getAppDetails: () => AppDetails;\n  getFeatureFlags: () => Record<string, boolean>;\n  trackEvent?: (params: TrackEventParams) => Promise<void>;\n}\n\n// Sample responses used both as fallback when the backend fails and by MockHardcopyService.\nexport const MOCK_HARDCOPY_RESPONSE: Partial<Record<WidgetTypeV3, HardcopyResponse>> = {\n  [WidgetTypeV3.PromptCarouselV3]: {\n    responseId: uuid(),\n    language: 'en',\n    values: {\n      promptButtonTexts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n        'Can I return items?',\n      ],\n    },\n  },\n  [WidgetTypeV3.TitledPromptCarouselV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Need some help?',\n      promptButtonTexts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n        'Can I return items?',\n      ],\n    },\n  },\n  [WidgetTypeV3.SocialProofV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      numberOfCustomersText: '123 customers',\n      customerQueryText: 'found what they were looking for...',\n      primaryButtonText: 'Start shopping',\n      secondaryButtonTitleText: 'Popular searches',\n      secondaryButtonTexts: [\n        'Why should I buy from you?',\n        'How do I return an item?',\n        'New arrivals',\n        'Sale items',\n        'Popular items',\n      ],\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.TypingAnimationV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      headlineText: 'Need help finding',\n      animatedTextSequence: [\n        'the perfect gift for your loved ones?',\n        'something special for the holidays?',\n        'the ideal present for someone special?',\n      ],\n      hintText: 'Ask me anything',\n      promptButtonTexts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n      ],\n      textFieldAriaLabel: 'Ask me anything',\n    },\n  },\n  [WidgetTypeV3.ChatPreviewComparisonV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      headlineText: 'Need help comparing?',\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.ChatPreviewLoadingV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.ChatPreviewV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.PromptButtonCarouselWithImageV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Need some help?',\n      promptButtonsTexts: ['Help me find a product', \"What's on your mind?\", 'Talk to a human'],\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.ProductCardV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      headline: 'Discover Your Perfect Style',\n      animatedText: [\n        'the perfect outfit for any occasion',\n        'trending fashion that fits your lifestyle',\n        'quality pieces that last',\n      ],\n      prompts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n        'Can I return items?',\n      ],\n      placeholder: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.FloatingChatV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      welcomeMessageTitle: 'Welcome to Envive AI',\n      welcomeMessageText:\n        'Your personal shopper trained on the collective knowledge of thousands of real experts!',\n      chatFooterTextFieldPlaceholderText: 'Ask me anything...',\n      disclaimerText: 'This is a disclaimer...',\n      leftToggleLabel: 'Shop with AI',\n      rightToggleLabel: 'Live support',\n    },\n  },\n  [WidgetTypeV3.FullPageSalesAgentV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      welcomeMessageTitle: 'Welcome to Envive AI',\n      welcomeMessageText:\n        'Your personal shopper trained on the collective knowledge of thousands of real experts!',\n      chatFooterTextFieldPlaceholderText: 'Ask me anything...',\n      disclaimerText: 'This is a disclaimer...',\n      welcomeOverlayLinkListTitle: 'Explore more',\n    },\n  },\n};\n\nconst convertToHardcopyResponse = (response: WidgetText): HardcopyResponse => ({\n  responseId: response.responseId,\n  language: response.language,\n  rawValues: response.values,\n  values: Object.fromEntries(\n    Object.entries(response.values).map(([key, value]) => [\n      toCamelCase(key),\n      value.length === 1 ? value[0].value : value.map(v => v.value),\n    ]),\n  ),\n});\n\nexport class HardcopyService implements IHardcopyService {\n  constructor(private config: HardcopyServiceConfig) {}\n\n  async getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse> {\n    const overrideConfigVersion =\n      getQueryParam('spiffy_config_version') ||\n      getQueryParam('envive_config_version') ||\n      getAtomStore().get(resolvedBaseConfigVersionAtom) ||\n      undefined;\n\n    const widgetTextRequest: WidgetTextRequest = {\n      requestId: uuid(),\n      widgetType: request.widgetType,\n      context: this.config.getAppDetails(),\n      featureFlags: this.config.getFeatureFlags(),\n      language: navigator.languages[0] || 'en',\n      overrideConfigVersion,\n      url: window.location.href,\n    };\n\n    // The Widget Text events must carry the API-facing (translated) widget type, not the\n    // internal one: the AI-suggestions accounting joins these events against the backend\n    // registry, which is keyed by the wire type (e.g. ProductCardV3 is sent — and stored —\n    // as ImagePromptCardV3). Stamping the internal name here zeroed those stats. An\n    // unmapped type keeps the internal name — analytics must never block serving.\n    let wireWidgetType: string = request.widgetType;\n    try {\n      wireWidgetType = coreWidgetTypeToApiWidgetType(request.widgetType);\n    } catch {\n      logger.logDebug('no wire mapping for widget type — keeping internal name', {\n        widgetType: request.widgetType,\n      });\n    }\n\n    this.config.trackEvent?.({\n      eventName: EnviveMetricsEventName.WidgetTextRequest,\n      eventProps: {\n        widget_type: wireWidgetType,\n        request_id: widgetTextRequest.requestId,\n      },\n    });\n\n    try {\n      const response = await withTimeout(\n        CommerceApiClient.getHardcopy(widgetTextRequest),\n        HARDCOPY_TIMEOUT_MS,\n      );\n      if (response) {\n        const convertedResponse = convertToHardcopyResponse(response);\n        logger.logDebug('converted response', convertedResponse);\n        this.config.trackEvent?.({\n          eventName: EnviveMetricsEventName.WidgetTextResponse,\n          eventProps: {\n            widget_type: wireWidgetType,\n            response_id: response.responseId,\n            widget_text: response.values,\n            request_id: widgetTextRequest.requestId,\n            // Which method served each overridden slot — training/attribution\n            // reads this from the analytics event; passed through verbatim.\n            ...(response.aiSuggestionsAttributionBySlot\n              ? { ai_suggestions_attribution_by_slot: response.aiSuggestionsAttributionBySlot }\n              : {}),\n          },\n        });\n        return convertedResponse;\n      }\n    } catch (error) {\n      logger.logError('error getting hardcopy from backend', error);\n    }\n\n    const mockResponse = MOCK_HARDCOPY_RESPONSE[request.widgetType];\n    if (mockResponse) {\n      logger.logDebug('no real response, using mock', mockResponse);\n      return mockResponse;\n    }\n    throw new Error(`No hardcopy response found for widget type: ${request.widgetType}`);\n  }\n}\n\nexport class MockHardcopyService implements IHardcopyService {\n  constructor(private overrides: Partial<Record<WidgetTypeV3, HardcopyResponse>> = {}) {}\n\n  async getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse> {\n    const fallbackWidgetType =\n      request.widgetType === WidgetTypeV3.ProductCardV3\n        ? WidgetTypeV3.ImagePromptCardV3\n        : request.widgetType;\n\n    const response =\n      this.overrides[request.widgetType] ??\n      this.overrides[fallbackWidgetType] ??\n      MOCK_HARDCOPY_RESPONSE[request.widgetType];\n\n    if (!response) {\n      throw new Error(`No hardcopy response found for widget type: ${request.widgetType}`);\n    }\n    return response;\n  }\n}\n"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"hardcopyService.js","names":["Logger","timer: ReturnType<typeof setTimeout>","MOCK_HARDCOPY_RESPONSE: Partial<Record<WidgetTypeV3, HardcopyResponse>>","uuid","config: HardcopyServiceConfig","widgetTextRequest: WidgetTextRequest","wireWidgetType: string","fallbackReason: 'timeout' | 'error' | undefined","CommerceApiClient","overrides: Partial<Record<WidgetTypeV3, HardcopyResponse>>"],"sources":["../../../src/services/hardcopyService/hardcopyService.ts"],"sourcesContent":["import { v4 as uuid } from 'uuid';\nimport CommerceApiClient from 'src/application/commerce-api';\nimport { WidgetString, WidgetText } from 'src/application/models/api/widgetText';\nimport { WidgetTextRequest } from 'src/application/models/api/widgetTextRequest';\nimport { toCamelCase } from 'src/application/models/utils/snakeToCamelTransformer';\nimport { getQueryParam } from 'src/application/utils';\nimport { coreWidgetTypeToApiWidgetType } from 'src/application/utils/widgetTextRequestToApiRequest';\nimport { UserEvent } from 'src/application/models';\nimport Logger from 'src/application/logging/logger';\nimport { AppDetails } from 'src/atoms/app';\nimport { getAtomStore } from 'src/atoms/atomStore/atomStore';\nimport { resolvedBaseConfigVersionAtom } from 'src/atoms/envive/resolvedBaseConfigVersion';\nimport { WidgetTypeV3 } from 'src/contexts/typesV3';\nimport { EnviveMetricsEventName, TrackEventParams } from '../amplitudeService';\n\nconst logger = new Logger('hardcopyService');\n\n// Longest a hardcopy request may hang before we stop waiting for it. The backend-error\n// path below already falls back to static copy, but a request that never settles at all\n// never reaches that catch — it left the widget's loading latch unresolved forever, which\n// is the \"PLP staying in loading state\" failure. Racing the request against this timeout\n// turns a hang into the same fallback path an error takes, so the widget always leaves its\n// loading state.\n//\n// Kept under the ~4-5s at which session replays show shoppers abandon a still-loading\n// widget: a rescue that fires after they've left helps no one. When it fires, the catch\n// below logs an error (message includes \"timed out\") — that log is the signal monitoring\n// can count to measure how often hardcopy stalls.\nexport const HARDCOPY_TIMEOUT_MS = 4000;\n\n// Reject if `promise` has not settled within `ms`. The underlying request is not aborted\n// (a late response is simply discarded) — the only goal is to stop *waiting*, so the\n// caller's error handling can run.\nconst withTimeout = <T>(promise: Promise<T>, ms: number): Promise<T> => {\n  let timer: ReturnType<typeof setTimeout>;\n  const timeout = new Promise<never>((_, reject) => {\n    timer = setTimeout(() => reject(new Error(`hardcopy request timed out after ${ms}ms`)), ms);\n  });\n  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer)) as Promise<T>;\n};\n\nexport interface HardcopyRequest {\n  widgetType: WidgetTypeV3;\n  userEvent: UserEvent;\n}\n\nexport type HardcopyResponse = {\n  responseId: string;\n  language: string;\n  rawValues?: Record<string, WidgetString | WidgetString[]>;\n  values: Record<string, string | string[]>;\n  // How the copy was served, for widget-load diagnostics: 'api' = live backend response,\n  // 'static' = fell back to the bundled MOCK_HARDCOPY_RESPONSE after a backend error or timeout.\n  servedFrom?: 'api' | 'static';\n  fallbackReason?: 'timeout' | 'error';\n};\n\nexport interface IHardcopyService {\n  getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse>;\n}\n\nexport interface HardcopyServiceConfig {\n  getAppDetails: () => AppDetails;\n  getFeatureFlags: () => Record<string, boolean>;\n  trackEvent?: (params: TrackEventParams) => Promise<void>;\n}\n\n// Sample responses used both as fallback when the backend fails and by MockHardcopyService.\nexport const MOCK_HARDCOPY_RESPONSE: Partial<Record<WidgetTypeV3, HardcopyResponse>> = {\n  [WidgetTypeV3.PromptCarouselV3]: {\n    responseId: uuid(),\n    language: 'en',\n    values: {\n      promptButtonTexts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n        'Can I return items?',\n      ],\n    },\n  },\n  [WidgetTypeV3.TitledPromptCarouselV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Need some help?',\n      promptButtonTexts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n        'Can I return items?',\n      ],\n    },\n  },\n  [WidgetTypeV3.SocialProofV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      numberOfCustomersText: '123 customers',\n      customerQueryText: 'found what they were looking for...',\n      primaryButtonText: 'Start shopping',\n      secondaryButtonTitleText: 'Popular searches',\n      secondaryButtonTexts: [\n        'Why should I buy from you?',\n        'How do I return an item?',\n        'New arrivals',\n        'Sale items',\n        'Popular items',\n      ],\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.TypingAnimationV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      headlineText: 'Need help finding',\n      animatedTextSequence: [\n        'the perfect gift for your loved ones?',\n        'something special for the holidays?',\n        'the ideal present for someone special?',\n      ],\n      hintText: 'Ask me anything',\n      promptButtonTexts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n      ],\n      textFieldAriaLabel: 'Ask me anything',\n    },\n  },\n  [WidgetTypeV3.ChatPreviewComparisonV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      headlineText: 'Need help comparing?',\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.ChatPreviewLoadingV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.ChatPreviewV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Shopping Assistant',\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.PromptButtonCarouselWithImageV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      titleLabel: 'Need some help?',\n      promptButtonsTexts: ['Help me find a product', \"What's on your mind?\", 'Talk to a human'],\n      textFieldPlaceholderText: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.ProductCardV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      headline: 'Discover Your Perfect Style',\n      animatedText: [\n        'the perfect outfit for any occasion',\n        'trending fashion that fits your lifestyle',\n        'quality pieces that last',\n      ],\n      prompts: [\n        'What are your best sellers?',\n        'Show me summer dresses',\n        'Do you have free shipping?',\n        'What sizes are available?',\n        'Can I return items?',\n      ],\n      placeholder: 'Ask me anything...',\n    },\n  },\n  [WidgetTypeV3.FloatingChatV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      welcomeMessageTitle: 'Welcome to Envive AI',\n      welcomeMessageText:\n        'Your personal shopper trained on the collective knowledge of thousands of real experts!',\n      chatFooterTextFieldPlaceholderText: 'Ask me anything...',\n      disclaimerText: 'This is a disclaimer...',\n      leftToggleLabel: 'Shop with AI',\n      rightToggleLabel: 'Live support',\n    },\n  },\n  [WidgetTypeV3.FullPageSalesAgentV3]: {\n    responseId: 'mock-response-id',\n    language: 'en',\n    values: {\n      welcomeMessageTitle: 'Welcome to Envive AI',\n      welcomeMessageText:\n        'Your personal shopper trained on the collective knowledge of thousands of real experts!',\n      chatFooterTextFieldPlaceholderText: 'Ask me anything...',\n      disclaimerText: 'This is a disclaimer...',\n      welcomeOverlayLinkListTitle: 'Explore more',\n    },\n  },\n};\n\nconst convertToHardcopyResponse = (response: WidgetText): HardcopyResponse => ({\n  responseId: response.responseId,\n  language: response.language,\n  rawValues: response.values,\n  values: Object.fromEntries(\n    Object.entries(response.values).map(([key, value]) => [\n      toCamelCase(key),\n      value.length === 1 ? value[0].value : value.map(v => v.value),\n    ]),\n  ),\n});\n\nexport class HardcopyService implements IHardcopyService {\n  constructor(private config: HardcopyServiceConfig) {}\n\n  async getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse> {\n    const overrideConfigVersion =\n      getQueryParam('spiffy_config_version') ||\n      getQueryParam('envive_config_version') ||\n      getAtomStore().get(resolvedBaseConfigVersionAtom) ||\n      undefined;\n\n    const widgetTextRequest: WidgetTextRequest = {\n      requestId: uuid(),\n      widgetType: request.widgetType,\n      context: this.config.getAppDetails(),\n      featureFlags: this.config.getFeatureFlags(),\n      language: navigator.languages[0] || 'en',\n      overrideConfigVersion,\n      url: window.location.href,\n    };\n\n    // The Widget Text events must carry the API-facing (translated) widget type, not the\n    // internal one: the AI-suggestions accounting joins these events against the backend\n    // registry, which is keyed by the wire type (e.g. ProductCardV3 is sent — and stored —\n    // as ImagePromptCardV3). Stamping the internal name here zeroed those stats. An\n    // unmapped type keeps the internal name — analytics must never block serving.\n    let wireWidgetType: string = request.widgetType;\n    try {\n      wireWidgetType = coreWidgetTypeToApiWidgetType(request.widgetType);\n    } catch {\n      logger.logDebug('no wire mapping for widget type — keeping internal name', {\n        widgetType: request.widgetType,\n      });\n    }\n\n    this.config.trackEvent?.({\n      eventName: EnviveMetricsEventName.WidgetTextRequest,\n      eventProps: {\n        widget_type: wireWidgetType,\n        request_id: widgetTextRequest.requestId,\n      },\n    });\n\n    // Reason the API path failed, surfaced on the static fallback for widget-load diagnostics.\n    let fallbackReason: 'timeout' | 'error' | undefined;\n    try {\n      const response = await withTimeout(\n        CommerceApiClient.getHardcopy(widgetTextRequest),\n        HARDCOPY_TIMEOUT_MS,\n      );\n      if (response) {\n        const convertedResponse = convertToHardcopyResponse(response);\n        logger.logDebug('converted response', convertedResponse);\n        this.config.trackEvent?.({\n          eventName: EnviveMetricsEventName.WidgetTextResponse,\n          eventProps: {\n            widget_type: wireWidgetType,\n            response_id: response.responseId,\n            widget_text: response.values,\n            request_id: widgetTextRequest.requestId,\n            // Which method served each overridden slot — training/attribution\n            // reads this from the analytics event; passed through verbatim.\n            ...(response.aiSuggestionsAttributionBySlot\n              ? { ai_suggestions_attribution_by_slot: response.aiSuggestionsAttributionBySlot }\n              : {}),\n          },\n        });\n        return { ...convertedResponse, servedFrom: 'api' };\n      }\n    } catch (error) {\n      logger.logError('error getting hardcopy from backend', error);\n      fallbackReason =\n        error instanceof Error && error.message.includes('timed out') ? 'timeout' : 'error';\n    }\n\n    const mockResponse = MOCK_HARDCOPY_RESPONSE[request.widgetType];\n    if (mockResponse) {\n      logger.logDebug('no real response, using mock', mockResponse);\n      return { ...mockResponse, servedFrom: 'static', fallbackReason: fallbackReason ?? 'error' };\n    }\n    throw new Error(`No hardcopy response found for widget type: ${request.widgetType}`);\n  }\n}\n\nexport class MockHardcopyService implements IHardcopyService {\n  constructor(private overrides: Partial<Record<WidgetTypeV3, HardcopyResponse>> = {}) {}\n\n  async getHardcopy(request: HardcopyRequest): Promise<HardcopyResponse> {\n    const fallbackWidgetType =\n      request.widgetType === WidgetTypeV3.ProductCardV3\n        ? WidgetTypeV3.ImagePromptCardV3\n        : request.widgetType;\n\n    const response =\n      this.overrides[request.widgetType] ??\n      this.overrides[fallbackWidgetType] ??\n      MOCK_HARDCOPY_RESPONSE[request.widgetType];\n\n    if (!response) {\n      throw new Error(`No hardcopy response found for widget type: ${request.widgetType}`);\n    }\n    return response;\n  }\n}\n"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@envive-ai/react-hooks",
-  "version": "0.3.63",
+  "version": "0.3.64",
   "description": "React hooks for connecting to Envive AI services.",
   "keywords": [
     "react",
@@ -414,6 +414,10 @@
       "import": "./dist/hooks/WidgetInteraction/utils.js",
       "require": "./dist/hooks/WidgetInteraction/utils.cjs"
     },
+    "./hooks/WidgetLoadDiagnostics": {
+      "import": "./dist/hooks/WidgetLoadDiagnostics/index.js",
+      "require": "./dist/hooks/WidgetLoadDiagnostics/index.cjs"
+    },
     "./interceptors": {
       "import": "./dist/interceptors/index.js",
       "require": "./dist/interceptors/index.cjs"

package/src/application/models/featureGates.ts

@@ -46,4 +46,10 @@ export enum FeatureGates {
   // instead of the legacy getProductsConfigByVersion / getColorsAndFrontend
   // path.
   UseUnifiedConfig = 'use_unified_config',
+  // Kill switch for the [Envive] Diagnostics widget-load events (mount / outcome / stall).
+  // Diagnostics are ON by default for every org so we can gather a cross-merchant baseline and
+  // tell whether one merchant's stuck rate is anomalous. Set this gate true — globally or
+  // per-org, via Statsig — to shut them off (e.g. after the data-gathering window, or if the
+  // volume is a problem).
+  IsWidgetDiagnosticsDisabled = 'is_widget_diagnostics_disabled',
 }

package/src/hooks/Intersection/useIntersection.ts

@@ -40,12 +40,19 @@ export const useIntersection = (
   element: RefObject<HTMLElement>,
   rootMargin: string,
   logContext?: Record<string, unknown>,
+  // Called the first time visibility is forced by the reconcile fallback (observer stayed
+  // silent for an on-screen element). Lets callers record that this widget's visibility came
+  // from the fallback rather than the observer — the diagnostic for observer failures.
+  onFallbackEngaged?: () => void,
 ) => {
   const [isVisible, setIsVisible] = useState(false);
   const observerRef = useRef<IntersectionObserver | null>(null);
   const observedNodeRef = useRef<HTMLElement | null>(null);
   const logContextRef = useRef(logContext);
   logContextRef.current = logContext;
+  const onFallbackEngagedRef = useRef(onFallbackEngaged);
+  onFallbackEngagedRef.current = onFallbackEngaged;
+  const fallbackEngagedRef = useRef(false);
 
   // 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
@@ -112,6 +119,10 @@ export const useIntersection = (
             },
           );
         }
+        if (!fallbackEngagedRef.current) {
+          fallbackEngagedRef.current = true;
+          onFallbackEngagedRef.current?.();
+        }
         setIsVisible(true);
       }
     };

package/src/hooks/TrackComponentVisibleEvent/__tests__/useTrackComponentVisibleEvent.test.tsx

@@ -0,0 +1,64 @@
+import { act, renderHook } from '@testing-library/react';
+import { RefObject } from 'react';
+import { useTrackComponentVisibleEvent } from '../useTrackComponentVisibleEvent';
+
+// Control the observer's isVisible and capture the fallback callback.
+let mockIsVisible = false;
+let capturedOnFallback: (() => void) | undefined;
+
+vi.mock('src/hooks/Intersection/useIntersection', () => ({
+  useIntersection: (
+    _el: unknown,
+    _rm: unknown,
+    _ctx: unknown,
+    onFallback?: () => void,
+  ): boolean => {
+    capturedOnFallback = onFallback;
+    return mockIsVisible;
+  },
+}));
+
+vi.mock('src/contexts/amplitudeContext/amplitudeContext', () => ({
+  useAmplitude: () => ({ trackEvent: vi.fn(), isReady: true }),
+}));
+
+vi.mock('jotai', async (importOriginal: () => Promise<typeof import('jotai')>) => {
+  const actual = await importOriginal();
+  return { ...actual, useAtomValue: () => null };
+});
+
+const ref = { current: document.createElement('div') } as RefObject<HTMLElement>;
+
+beforeEach(() => {
+  mockIsVisible = false;
+  capturedOnFallback = undefined;
+});
+
+describe('useTrackComponentVisibleEvent visibilitySource', () => {
+  it("stays 'pending' until visibility is established (so an eager load never claims 'observer')", () => {
+    const { result } = renderHook(() => useTrackComponentVisibleEvent(ref, {}));
+    expect(result.current.isVisible).toBe(false);
+    expect(result.current.visibilitySource).toBe('pending');
+  });
+
+  it("resolves to 'observer' when the observer reports the element visible", () => {
+    const { result, rerender } = renderHook(() => useTrackComponentVisibleEvent(ref, {}));
+    act(() => {
+      mockIsVisible = true;
+      rerender();
+    });
+    expect(result.current.visibilitySource).toBe('observer');
+  });
+
+  it("records 'fallback' when the reconcile fallback forces visibility (observer stayed silent)", () => {
+    const { result, rerender } = renderHook(() => useTrackComponentVisibleEvent(ref, {}));
+    act(() => {
+      // Fallback fires first (as it does in useIntersection, before its own setIsVisible)...
+      capturedOnFallback?.();
+      // ...then visibility flips true.
+      mockIsVisible = true;
+      rerender();
+    });
+    expect(result.current.visibilitySource).toBe('fallback');
+  });
+});

package/src/hooks/TrackComponentVisibleEvent/useTrackComponentVisibleEvent.ts

@@ -1,5 +1,5 @@
 import { useAtomValue } from 'jotai';
-import { RefObject, useEffect, useRef } from 'react';
+import { RefObject, useEffect, useRef, useState } from 'react';
 import Logger from 'src/application/logging/logger';
 import { pageVariantInfoAtom } from 'src/atoms/app';
 import { useAmplitude } from 'src/contexts/amplitudeContext/amplitudeContext';
@@ -34,10 +34,29 @@ export const useTrackComponentVisibleEvent = (
   eventProps?: Record<string, unknown>,
   rootMargin: string = '0px',
   enabled: boolean = true,
-): { isVisible: boolean } => {
+): { isVisible: boolean; visibilitySource: 'observer' | 'fallback' | 'pending' } => {
+  // How visibility was established, for widget-load diagnostics:
+  //  - 'pending'  — not confirmed by either path yet. Stays this way for a `deferLoading: false`
+  //                 widget whose requests settle before the observer ever reports, so we don't
+  //                 falsely claim 'observer' for a load that never waited on visibility.
+  //  - 'observer' — the IntersectionObserver reported the element visible.
+  //  - 'fallback' — the reconcile fallback had to force it (observer stayed silent on-screen).
+  // State (not a ref) so consumers reliably re-render when the source resolves.
+  const [visibilitySource, setVisibilitySource] = useState<'observer' | 'fallback' | 'pending'>(
+    'pending',
+  );
   // 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 isVisible = useIntersection(element, rootMargin, eventProps, () => {
+    // The observer stayed silent on-screen and the fallback forced visibility. This is recorded
+    // before useIntersection's own setIsVisible, so it wins over the 'observer' resolution below.
+    setVisibilitySource(prev => (prev === 'pending' ? 'fallback' : prev));
+  });
+  // Resolve 'pending' → 'observer' once the observer establishes visibility; a 'fallback'
+  // already recorded above is preserved.
+  useEffect(() => {
+    if (isVisible) setVisibilitySource(prev => (prev === 'pending' ? 'observer' : prev));
+  }, [isVisible]);
   const hasTrackedEvent = useRef(false);
   const { trackEvent } = useAmplitude();
   const variantInfo = useAtomValue(pageVariantInfoAtom);
@@ -87,5 +106,5 @@ export const useTrackComponentVisibleEvent = (
     });
     hasTrackedEvent.current = true;
   }, [enabled, isVisible, eventProps, trackEvent]);
-  return { isVisible };
+  return { isVisible, visibilitySource };
 };

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]);
+};