@dynamic-labs/react-native-extension 4.83.2-alpha.0 → 4.84.0

package/index.js

@@ -1,19 +1,19 @@
 import { assertPackageVersion } from '@dynamic-labs/assert-package-version';
 import { StyleSheet, Platform } from 'react-native';
-import { useEffect, useRef, useCallback, useState } from 'react';
+import { useEffect, useRef, useCallback, useState, useMemo } from 'react';
 import { WebView as WebView$1 } from 'react-native-webview';
 import { Logger } from '@dynamic-labs/logger';
 import { messageTransportDataJsonReviver, parseMessageTransportData, messageTransportDataJsonReplacer, createRequestChannel } from '@dynamic-labs/message-transport';
 import { sdkHasLoadedEventName } from '@dynamic-labs/webview-messages';
+import { setItemAsync, getItemAsync, deleteItemAsync } from 'expo-secure-store';
 import { jsx } from 'react/jsx-runtime';
 import { requireNativeModule } from 'expo-modules-core';
 import { Passkey } from 'react-native-passkey';
 import { createURL, getInitialURL, addEventListener, openURL } from 'expo-linking';
 import { openAuthSessionAsync } from 'expo-web-browser';
-import { getItemAsync, deleteItemAsync, setItemAsync } from 'expo-secure-store';
 import { createPasskey, PasskeyStamper } from '@turnkey/react-native-passkey-stamper';
 
-var version = "4.83.2-alpha.0";
+var version = "4.84.0";
 
 function _extends() {
   return _extends = Object.assign ? Object.assign.bind() : function (n) {
@@ -107,22 +107,157 @@ const WEBVIEW_START_TIME_PARAM = 'webviewStartTime';
 
 const hasClearStateInUrl = webViewUrl => Boolean(webViewUrl.searchParams.get(CLEAR_STATE_PARAM));
 
-const MANIFEST_MESSAGE_TYPE$1 = 'manifest';
-const RETRY_QUERY_PARAM = 'retry';
-const emptyPerAttemptState$1 = () => ({
+/**
+ * Wire-format `type` of a webview-side `manifest` request.
+ *
+ * `requestChannel.request('manifest')` sends a `MessageTransportData` whose
+ * `type` is the literal request name. The host replies with `manifest__ack`,
+ * which we ignore: receiving the request is sufficient evidence that the
+ * webview JS bundle is alive and the message bridge works.
+ */
+const MANIFEST_MESSAGE_TYPE = 'manifest';
+const emptyTimings = () => ({
   htmlLoadStartedAt: null,
   htmlLoadedAt: null,
   manifestReceivedAt: null,
   onLoadEndAt: null,
   sdkReadyAt: null
 });
-const diffMs$1 = (later, earlier) => later !== null && earlier !== null ? later - earlier : null;
+const diffMs = (later, earlier) => later !== null && earlier !== null ? later - earlier : null;
+/**
+ * Derive cross-phase durations from raw timestamps. The four durations
+ * are what end up in the failure / success log meta:
+ *
+ * - `htmlLoadMs` — `onLoadStart` to `onLoad`; native HTML fetch
+ * - `onLoadToOnLoadEndMs` — `onLoad` to `onLoadEnd`; native render/parse
+ * - `manifestReceivedMs` — `onLoadEnd` to first `manifest` request from
+ *   the webview JS; "JS bundle is alive" signal
+ * - `sdkReadyMs` — `onLoadEnd` to first `sdkHasLoaded` event from the
+ *   webview JS; "SDK fully bootstrapped" signal
+ */
+const computePhaseDurations = timings => ({
+  htmlLoadMs: diffMs(timings.htmlLoadedAt, timings.htmlLoadStartedAt),
+  manifestReceivedMs: diffMs(timings.manifestReceivedAt, timings.onLoadEndAt),
+  onLoadToOnLoadEndMs: diffMs(timings.onLoadEndAt, timings.htmlLoadedAt),
+  sdkReadyMs: diffMs(timings.sdkReadyAt, timings.onLoadEndAt)
+});
+/**
+ * Build the success-shape meta from a {@link WebViewPhaseTimerCore}
+ * snapshot plus the path-specific fields. Both call sites call this
+ * with their own context (RN reads `hadClearState` / `retryCount` from
+ * the URL; embedded passes constants) so the success-log payload stays
+ * identical across the two paths.
+ */
+const buildSuccessMeta = ({
+  core,
+  hadClearState,
+  loadingTimeoutMs,
+  recoveryTimeoutMs,
+  retryCount,
+  webviewUrl
+}) => Object.assign(Object.assign({
+  hadClearState,
+  loadingTimeoutMs,
+  recoveryTimeoutMs,
+  retryCount,
+  webviewUrl
+}, computePhaseDurations(core.getTimings())), core.getCounters());
+/**
+ * Shared state machine driving WebView load-phase instrumentation.
+ *
+ * Both the React `<WebView>` (RN bridge) and the native embedded WebView
+ * (native bridge) feed lifecycle events into this core and produce
+ * matching meta from the same timings + counters. Each path layers its
+ * own path-specific fields (`hadClearState`, `retryCount`, etc.) on top
+ * of the raw state this core exposes via `getTimings()` / `getCounters()`.
+ *
+ * The core owns the `core.messageTransport` subscription that captures
+ * the two webview-originated signals bracketing SDK bootstrap
+ * (`manifest` once the JS bundle is alive; `sdkHasLoadedEventName`
+ * once the SDK is fully ready). Native bridge lifecycle events come in
+ * via `recordEvent` instead.
+ */
+const createWebViewPhaseTimerCore = ({
+  core
+}) => {
+  let timings = emptyTimings();
+  let nativeErrorCount = 0;
+  let osKillCount = 0;
+  /**
+   * We only capture the first occurrence per attempt so that a healthy
+   * reload doesn't overwrite the timing from the attempt that ultimately
+   * failed.
+   */
+  const handleMessage = message => {
+    if (message.origin !== 'webview') return;
+    if (message.type === MANIFEST_MESSAGE_TYPE && timings.manifestReceivedAt === null) {
+      timings.manifestReceivedAt = Date.now();
+    }
+    if (message.type === sdkHasLoadedEventName && timings.sdkReadyAt === null) {
+      timings.sdkReadyAt = Date.now();
+    }
+  };
+  core.messageTransport.on(handleMessage);
+  return {
+    dispose: () => {
+      core.messageTransport.off(handleMessage);
+    },
+    getCounters: () => ({
+      nativeErrorCount,
+      osKillCount
+    }),
+    getTimings: () => timings,
+    recordEvent: event => {
+      const now = Date.now();
+      switch (event) {
+        case 'load_start':
+          timings = emptyTimings();
+          timings.htmlLoadStartedAt = now;
+          break;
+        case 'load':
+          timings.htmlLoadedAt = now;
+          break;
+        case 'load_end':
+          timings.onLoadEndAt = now;
+          break;
+        case 'native_error':
+          nativeErrorCount += 1;
+          break;
+        case 'os_kill':
+          osKillCount += 1;
+          break;
+      }
+    }
+  };
+};
+
+const RETRY_QUERY_PARAM = 'retry';
 const readRetryCount = webViewUrl => {
   const raw = webViewUrl.searchParams.get(RETRY_QUERY_PARAM);
   if (raw === null) return 0;
   const parsed = Number(raw);
   return Number.isFinite(parsed) ? parsed : 0;
 };
+/**
+ * Snapshot returned by the phase-timer core when it hasn't been
+ * instantiated yet (briefly true between hook construction and the
+ * `useEffect` running). Lets `getSuccessMeta` / `getMeta` produce a
+ * well-formed empty meta in that window without special-casing each
+ * field.
+ */
+const EMPTY_CORE_SNAPSHOT = {
+  getCounters: () => ({
+    nativeErrorCount: 0,
+    osKillCount: 0
+  }),
+  getTimings: () => ({
+    htmlLoadStartedAt: null,
+    htmlLoadedAt: null,
+    manifestReceivedAt: null,
+    onLoadEndAt: null,
+    sdkReadyAt: null
+  })
+};
 /**
  * Tracks how long each step of the WebView load took, so when we raise
  * `WebViewFailedToLoadError` we can attach the timings to the error log.
@@ -131,92 +266,231 @@ const readRetryCount = webViewUrl => {
  * timings (`webview.time_to_load_manifest`, `webview.time_to_sdk_ready`)
  * still come from the webview itself once it boots, but those don't help
  * when the webview never boots in the first place.
+ *
+ * The actual state machine lives in {@link createWebViewPhaseTimerCore},
+ * which is also reused by the embedded native WebView path. This hook
+ * only layers the React-specific bits (ref-based core lifetime tied to
+ * `useEffect`, URL-derived `hadClearState` / `retryCount`).
  */
 const useWebViewPhaseTimers = ({
   core,
-  webViewUrl,
   loadingTimeout,
-  recoveryTimeout
+  recoveryTimeout,
+  webViewUrl
 }) => {
-  const perAttemptRef = useRef(emptyPerAttemptState$1());
-  const nativeErrorCountRef = useRef(0);
-  const osKillCountRef = useRef(0);
+  const phaseCoreRef = useRef(null);
   const webViewUrlRef = useRef(webViewUrl);
   webViewUrlRef.current = webViewUrl;
   /**
-   * Listen on the message transport for the two webview-originated
-   * messages that mark "JS bundle alive" and "SDK ready".
-   *
-   * We only record the first occurrence per attempt so that a healthy
-   * reload doesn't overwrite the timing from the attempt that ultimately
-   * failed.
+   * Owning the message-transport subscription in `useEffect` matches the
+   * lifetime semantics any other React subscription would have, and lets
+   * us cleanly re-subscribe if `core` is ever swapped at runtime.
    */
   useEffect(() => {
-    const handler = message => {
-      if (message.origin !== 'webview') return;
-      if (message.type === MANIFEST_MESSAGE_TYPE$1 && perAttemptRef.current.manifestReceivedAt === null) {
-        perAttemptRef.current.manifestReceivedAt = Date.now();
-      }
-      if (message.type === sdkHasLoadedEventName && perAttemptRef.current.sdkReadyAt === null) {
-        perAttemptRef.current.sdkReadyAt = Date.now();
+    const phaseCore = createWebViewPhaseTimerCore({
+      core
+    });
+    phaseCoreRef.current = phaseCore;
+    return () => {
+      phaseCore.dispose();
+      if (phaseCoreRef.current === phaseCore) {
+        phaseCoreRef.current = null;
       }
     };
-    core.messageTransport.on(handler);
-    return () => core.messageTransport.off(handler);
   }, [core]);
   const recordEvent = useCallback(event => {
-    const now = Date.now();
-    switch (event) {
-      case 'load_start':
-        perAttemptRef.current = emptyPerAttemptState$1();
-        perAttemptRef.current.htmlLoadStartedAt = now;
-        break;
-      case 'load':
-        perAttemptRef.current.htmlLoadedAt = now;
-        break;
-      case 'load_end':
-        perAttemptRef.current.onLoadEndAt = now;
-        break;
-      case 'native_error':
-        nativeErrorCountRef.current += 1;
-        break;
-      case 'os_kill':
-        osKillCountRef.current += 1;
-        break;
-    }
+    var _a;
+    (_a = phaseCoreRef.current) === null || _a === void 0 ? void 0 : _a.recordEvent(event);
   }, []);
-  const getMeta = useCallback(({
-    phase
-  }) => {
+  const getSuccessMeta = useCallback(() => {
+    var _a;
     const url = webViewUrlRef.current;
-    const {
-      htmlLoadStartedAt,
-      htmlLoadedAt,
-      onLoadEndAt,
-      manifestReceivedAt,
-      sdkReadyAt
-    } = perAttemptRef.current;
-    return {
+    return buildSuccessMeta({
+      core: (_a = phaseCoreRef.current) !== null && _a !== void 0 ? _a : EMPTY_CORE_SNAPSHOT,
       hadClearState: hasClearStateInUrl(url),
-      htmlLoadMs: diffMs$1(htmlLoadedAt, htmlLoadStartedAt),
       loadingTimeoutMs: loadingTimeout,
-      manifestReceivedMs: diffMs$1(manifestReceivedAt, onLoadEndAt),
-      nativeErrorCount: nativeErrorCountRef.current,
-      onLoadToOnLoadEndMs: diffMs$1(onLoadEndAt, htmlLoadedAt),
-      osKillCount: osKillCountRef.current,
-      phase,
       recoveryTimeoutMs: recoveryTimeout,
       retryCount: readRetryCount(url),
-      sdkReadyMs: diffMs$1(sdkReadyAt, onLoadEndAt),
       webviewUrl: url.toString()
-    };
+    });
   }, [loadingTimeout, recoveryTimeout]);
+  const getMeta = useCallback(({
+    phase
+  }) => Object.assign(Object.assign({}, getSuccessMeta()), {
+    phase
+  }), [getSuccessMeta]);
   return {
     getMeta,
+    getSuccessMeta,
     recordEvent
   };
 };
 
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+const SUCCESS_LOG_KEY = 'webview.load_succeeded';
+/**
+ * Shared emission pattern for the `webview.load_succeeded`
+ * instrumentation log. Both the RN `<WebView>` and the embedded
+ * WebView fire the same event with the same payload shape after
+ * checking the same cooldown gate — this helper centralises that
+ * sequence so the two call sites stay aligned and any future field we
+ * add to the success log lands in both places automatically.
+ */
+const emitSuccessLog = _a => __awaiter(void 0, [_a], void 0, function* ({
+  cooldown,
+  core,
+  getMeta,
+  name
+}) {
+  if (!(yield cooldown.shouldEmit())) return;
+  logger.instrument(`${name} loaded successfully`, Object.assign({
+    environmentId: core.environmentId,
+    hostSdkSessionId: core.hostSdkSessionId,
+    key: SUCCESS_LOG_KEY,
+    time: 0
+  }, getMeta()));
+  yield cooldown.recordEmitted();
+});
+
+const SUCCESS_LOG_COOLDOWN_MS = 60 * 60 * 1000;
+const parseStoredTimestamp = raw => {
+  if (raw === null) return null;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) ? parsed : null;
+};
+/**
+ * Create a device-local cooldown gate for a `webview.load_succeeded`
+ * instrumentation log.
+ *
+ * Both `<WebView>` (RN bridge) and `<EmbeddedWebView>` (native bridge)
+ * emit the same success log; each instantiates its own cooldown with a
+ * dedicated storage key so emitting one log doesn't starve the other
+ * for an app that mounts both.
+ *
+ * - `shouldEmit` returns `true` when the cooldown has elapsed (or no
+ *   timestamp has ever been stored) and `false` while inside the
+ *   window. If secure-store throws on read we default to emitting —
+ *   losing a diagnostic log is worse than the rare duplicate.
+ * - `recordEmitted` persists the current timestamp so subsequent calls
+ *   within the window are suppressed. Write failures are swallowed
+ *   (logged as a warning) so they don't break the host wrapper —
+ *   worst case the next emit also goes through.
+ */
+const createSuccessLogCooldown = ({
+  name,
+  storageKey
+}) => ({
+  recordEmitted: (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (now = Date.now()) {
+    try {
+      yield setItemAsync(storageKey, now.toString());
+    } catch (error) {
+      logger.warn(`Failed to persist ${name} success-log cooldown timestamp`, {
+        error: String(error)
+      });
+    }
+  }),
+  shouldEmit: (...args_2) => __awaiter(void 0, [...args_2], void 0, function* (now = Date.now()) {
+    try {
+      const raw = yield getItemAsync(storageKey);
+      const lastEmittedAt = parseStoredTimestamp(raw);
+      if (lastEmittedAt === null) return true;
+      return now - lastEmittedAt >= SUCCESS_LOG_COOLDOWN_MS;
+    } catch (error) {
+      logger.warn(`Failed to read ${name} success-log cooldown timestamp; emitting anyway`, {
+        error: String(error)
+      });
+      return true;
+    }
+  })
+});
+
+const SUCCESS_LOG_COOLDOWN_STORAGE_KEY = 'dynamic.webview.successLogLastEmittedAt';
+/**
+ * Emit a `webview.load_succeeded` instrumentation log the first time
+ * the SDK signals it's ready, gated by a device-local 1h cooldown so a
+ * customer with many WebView mounts (or many app launches) doesn't spam
+ * the logs pipeline.
+ *
+ * The error path is unaffected: failures keep going through
+ * `logger.error(WebViewFailedToLoadError, meta)` with no cooldown.
+ *
+ * The hook intentionally fires only once per mount (`hasEmittedRef`):
+ * after a successful boot we don't expect another `sdkHasLoaded` for
+ * the same WebView lifetime, and emitting twice for the same load would
+ * be misleading.
+ *
+ * Cooldown gating + log emission are delegated to the shared
+ * `successLog` helpers so this hook and the embedded native WebView
+ * path stay in lockstep on payload shape and storage semantics; the
+ * dedicated storage key here keeps the RN-path cooldown independent
+ * from the embedded path's.
+ */
+const useWebViewSuccessLog = ({
+  core,
+  getSuccessMeta
+}) => {
+  const hasEmittedRef = useRef(false);
+  const getSuccessMetaRef = useRef(getSuccessMeta);
+  getSuccessMetaRef.current = getSuccessMeta;
+  useEffect(() => {
+    const cooldown = createSuccessLogCooldown({
+      name: 'webview',
+      storageKey: SUCCESS_LOG_COOLDOWN_STORAGE_KEY
+    });
+    const handler = message => __awaiter(void 0, void 0, void 0, function* () {
+      if (message.origin !== 'webview') return;
+      if (message.type !== sdkHasLoadedEventName) return;
+      if (hasEmittedRef.current) return;
+      hasEmittedRef.current = true;
+      try {
+        yield emitSuccessLog({
+          cooldown,
+          core,
+          getMeta: getSuccessMetaRef.current,
+          name: 'Webview'
+        });
+      } catch (err) {
+        logger.warn('useWebViewSuccessLog.emitSuccessLog failed', {
+          error: String(err)
+        });
+      }
+    });
+    core.messageTransport.on(handler);
+    return () => {
+      core.messageTransport.off(handler);
+    };
+  }, [core]);
+};
+
 const useWebViewVisibility = core => {
   const webViewVisibilityRequestChannelRef = useRef(createRequestChannel(core.messageTransport));
   const [visible, setVisible] = useState(false);
@@ -432,13 +706,18 @@ const WebView = ({
   } = useMessageTransportWebViewBridge(core, webViewRef);
   const {
     recordEvent,
-    getMeta
+    getMeta,
+    getSuccessMeta
   } = useWebViewPhaseTimers({
     core,
     loadingTimeout: _loadingTimeout,
     recoveryTimeout: _recoveryTimeout,
     webViewUrl
   });
+  useWebViewSuccessLog({
+    core,
+    getSuccessMeta
+  });
   const containerStyles = [styles['container'], visible ? styles.show : styles.hide];
   /**
    * Block the message transport when the webview is unmounted
@@ -536,10 +815,11 @@ const WebView = ({
     recordEvent('load_end');
     startRecoveryTimeout();
   }, [recordEvent, startRecoveryTimeout]);
+  const webViewUrlString = useMemo(() => webViewUrl.toString(), [webViewUrl]);
   return /*#__PURE__*/jsx(WebView$1, {
     ref: webViewRef,
     source: {
-      uri: webViewUrl.toString()
+      uri: webViewUrlString
     },
     containerStyle: containerStyles,
     style: styles['webview'],
@@ -557,7 +837,7 @@ const WebView = ({
       isTopFrame: request.isTopFrame,
       url: request.url
     }, webViewUrl)
-  });
+  }, webViewUrlString);
 };
 const createWebView = internalProps => {
   const WebViewWrapper = props => /*#__PURE__*/jsx(WebView, _extends({}, internalProps, props));
@@ -596,103 +876,51 @@ const getEmbeddedWebView = () => {
   }
 };
 
-const MANIFEST_MESSAGE_TYPE = 'manifest';
-const emptyPerAttemptState = () => ({
-  htmlLoadStartedAt: null,
-  htmlLoadedAt: null,
-  manifestReceivedAt: null,
-  onLoadEndAt: null,
-  sdkReadyAt: null
-});
-const diffMs = (later, earlier) => later !== null && earlier !== null ? later - earlier : null;
 /**
  * Non-React equivalent of `useWebViewPhaseTimers` for the embedded native
- * webview path. The embedded path is a singleton wired by `setupEmbeddedWebView`
- * (not a React component), so we expose the same phase-timing surface as a
- * plain factory.
+ * webview path. The embedded path is a singleton wired by
+ * `setupEmbeddedWebView` (not a React component), so we expose the same
+ * phase-timing surface as a plain factory.
  *
- * The hook and the factory are intentionally separate: the embedded path does
- * not have a retry or clear-state model, so `retryCount` is always `0` and
- * `hadClearState` is always `false` in the meta produced here. Sharing one
- * implementation would require either pulling React into a hot non-React path
- * or threading a stateless adapter through both consumers \u2014 the duplication
- * is small enough that keeping them separate stays cleaner.
+ * Both this factory and the hook delegate the actual state machine to
+ * {@link createWebViewPhaseTimerCore}; the only path-specific bits are:
+ *
+ * - `hadClearState` is always `false` (embedded path has no clear-state
+ *   recovery model — that's exclusive to the React `<WebView>` path's
+ *   loading-timeout recovery flow)
+ * - `retryCount` is always `0` (embedded path has no retry counter URL
+ *   query param either)
  */
 const createEmbeddedWebViewPhaseTimers = ({
   core,
-  webViewUrl,
   loadingTimeoutMs,
-  recoveryTimeoutMs
+  recoveryTimeoutMs,
+  webViewUrl
 }) => {
-  let perAttempt = emptyPerAttemptState();
-  let nativeErrorCount = 0;
-  let osKillCount = 0;
-  const handleMessage = message => {
-    if (message.origin !== 'webview') return;
-    if (message.type === MANIFEST_MESSAGE_TYPE && perAttempt.manifestReceivedAt === null) {
-      perAttempt.manifestReceivedAt = Date.now();
-    }
-    if (message.type === sdkHasLoadedEventName && perAttempt.sdkReadyAt === null) {
-      perAttempt.sdkReadyAt = Date.now();
-    }
-  };
-  core.messageTransport.on(handleMessage);
-  const recordEvent = event => {
-    const now = Date.now();
-    switch (event) {
-      case 'load_start':
-        perAttempt = emptyPerAttemptState();
-        perAttempt.htmlLoadStartedAt = now;
-        break;
-      case 'load':
-        perAttempt.htmlLoadedAt = now;
-        break;
-      case 'load_end':
-        perAttempt.onLoadEndAt = now;
-        break;
-      case 'native_error':
-        nativeErrorCount += 1;
-        break;
-      case 'os_kill':
-        osKillCount += 1;
-        break;
-    }
-  };
-  const getMeta = ({
-    phase
-  }) => {
-    const {
-      htmlLoadStartedAt,
-      htmlLoadedAt,
-      onLoadEndAt,
-      manifestReceivedAt,
-      sdkReadyAt
-    } = perAttempt;
-    return {
-      hadClearState: false,
-      htmlLoadMs: diffMs(htmlLoadedAt, htmlLoadStartedAt),
-      loadingTimeoutMs,
-      manifestReceivedMs: diffMs(manifestReceivedAt, onLoadEndAt),
-      nativeErrorCount,
-      onLoadToOnLoadEndMs: diffMs(onLoadEndAt, htmlLoadedAt),
-      osKillCount,
-      phase,
-      recoveryTimeoutMs,
-      retryCount: 0,
-      sdkReadyMs: diffMs(sdkReadyAt, onLoadEndAt),
-      webviewUrl: webViewUrl.toString()
-    };
-  };
-  const dispose = () => {
-    core.messageTransport.off(handleMessage);
-  };
+  const phaseCore = createWebViewPhaseTimerCore({
+    core
+  });
+  const getSuccessMeta = () => buildSuccessMeta({
+    core: phaseCore,
+    hadClearState: false,
+    loadingTimeoutMs,
+    recoveryTimeoutMs,
+    retryCount: 0,
+    webviewUrl: webViewUrl.toString()
+  });
   return {
-    dispose,
-    getMeta,
-    recordEvent
+    dispose: phaseCore.dispose,
+    getMeta: ({
+      phase
+    }) => Object.assign(Object.assign({}, getSuccessMeta()), {
+      phase
+    }),
+    getSuccessMeta,
+    recordEvent: phaseCore.recordEvent
   };
 };
 
+const EMBEDDED_SUCCESS_LOG_COOLDOWN_STORAGE_KEY = 'dynamic.embeddedWebView.successLogLastEmittedAt';
 const DEFAULT_LOADING_TIMEOUT_MS = 20000;
 const DEFAULT_RECOVERY_TIMEOUT_MS = 20000;
 // Wires the JS-side bridge to the native WKWebView singleton owned by Swift.
@@ -719,9 +947,14 @@ const setupEmbeddedWebView = ({
     recoveryTimeoutMs: _recoveryTimeoutMs,
     webViewUrl: builtUrl
   });
+  const successLogCooldown = createSuccessLogCooldown({
+    name: 'embedded webview',
+    storageKey: EMBEDDED_SUCCESS_LOG_COOLDOWN_STORAGE_KEY
+  });
   let loadingTimer = null;
   let recoveryTimer = null;
   let hasFailed = false;
+  let hasEmittedSuccessLog = false;
   const clearLoadingTimer = () => {
     if (loadingTimer !== null) {
       clearTimeout(loadingTimer);
@@ -762,12 +995,27 @@ const setupEmbeddedWebView = ({
   };
   core.messageTransport.on(handleHostMessage);
   // Watch for the webview-side SDK ready signal so we can clear the
-  // recovery timer. The phase-timer factory also subscribes for its own
-  // bookkeeping — both subscriptions are independent and idempotent.
+  // recovery timer and emit the success log. The phase-timer factory
+  // also subscribes for its own bookkeeping — both subscriptions are
+  // independent and idempotent. The factory subscribes first and so
+  // sees `sdkReadyAt` before this handler runs, which means the meta
+  // we emit below has the freshest `sdkReadyMs`. We only emit once
+  // per setup; a second SDK-ready event for the same load wouldn't
+  // represent a new successful boot.
   const handleSdkReady = message => {
     if (message.origin !== 'webview') return;
     if (message.type !== sdkHasLoadedEventName) return;
     clearRecoveryTimer();
+    if (hasEmittedSuccessLog || hasFailed) return;
+    hasEmittedSuccessLog = true;
+    emitSuccessLog({
+      cooldown: successLogCooldown,
+      core,
+      getMeta: phaseTimers.getSuccessMeta,
+      name: 'Embedded webview'
+    }).catch(err => {
+      logger.warn('EmbeddedWebView.emitSuccessLog failed', err);
+    });
   };
   core.messageTransport.on(handleSdkReady);
   const onMessageSub = native.addListener('onMessage', event => {
@@ -861,36 +1109,6 @@ const setupEmbeddedWebView = ({
   };
 };
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
 const setupPasskeyHandler = core => {
   const passkeyRequestChannel = createRequestChannel(core.messageTransport);
   passkeyRequestChannel.handle('passkey_register', _a => __awaiter(void 0, [_a], void 0, function* ({