@dynamic-labs/react-native-extension 4.92.3 → 4.93.0

package/index.cjs

@@ -6,9 +6,9 @@ var assertPackageVersion = require('@dynamic-labs/assert-package-version');
 var reactNative = require('react-native');
 var react = require('react');
 var reactNativeWebview = require('react-native-webview');
+var client = require('@dynamic-labs/client');
 var logger$1 = require('@dynamic-labs/logger');
 var messageTransport = require('@dynamic-labs/message-transport');
-var webviewMessages = require('@dynamic-labs/webview-messages');
 var expoSecureStore = require('expo-secure-store');
 var jsxRuntime = require('react/jsx-runtime');
 var expoModulesCore = require('expo-modules-core');
@@ -35,7 +35,7 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var version = "4.92.3";
+var version = "4.93.0";
 
 function _extends() {
   return _extends = Object.assign ? Object.assign.bind() : function (n) {
@@ -47,12 +47,35 @@ function _extends() {
   }, _extends.apply(null, arguments);
 }
 
-class WebViewFailedToLoadError extends Error {
-  constructor(meta) {
-    super('Could not load Dynamic WebView');
-    this.meta = meta;
-  }
-}
+/******************************************************************************
+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 logger = new logger$1.Logger('react-native-extension');
 
@@ -123,284 +146,40 @@ const useMessageTransportWebViewBridge = (core, webViewRef) => {
   };
 };
 
-const CLEAR_STATE_PARAM = 'clear-state';
-const ENVIRONMENT_ID_PARAM = 'environmentId';
-const WEBVIEW_START_TIME_PARAM = 'webviewStartTime';
-
-const hasClearStateInUrl = webViewUrl => Boolean(webViewUrl.searchParams.get(CLEAR_STATE_PARAM));
-
-/**
- * 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 = (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 === webviewMessages.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.
- *
- * The timings cover the host-side phases of the load — the webview-side
- * 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,
-  loadingTimeout,
-  recoveryTimeout,
-  webViewUrl
-}) => {
-  const phaseCoreRef = react.useRef(null);
-  const webViewUrlRef = react.useRef(webViewUrl);
-  webViewUrlRef.current = webViewUrl;
-  /**
-   * 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.
-   */
-  react.useEffect(() => {
-    const phaseCore = createWebViewPhaseTimerCore({
-      core
-    });
-    phaseCoreRef.current = phaseCore;
-    return () => {
-      phaseCore.dispose();
-      if (phaseCoreRef.current === phaseCore) {
-        phaseCoreRef.current = null;
-      }
-    };
-  }, [core]);
-  const recordEvent = react.useCallback(event => {
-    var _a;
-    (_a = phaseCoreRef.current) === null || _a === void 0 ? void 0 : _a.recordEvent(event);
-  }, []);
-  const getSuccessMeta = react.useCallback(() => {
-    var _a;
-    const url = webViewUrlRef.current;
-    return buildSuccessMeta({
-      core: (_a = phaseCoreRef.current) !== null && _a !== void 0 ? _a : EMPTY_CORE_SNAPSHOT,
-      hadClearState: hasClearStateInUrl(url),
-      loadingTimeoutMs: loadingTimeout,
-      recoveryTimeoutMs: recoveryTimeout,
-      retryCount: readRetryCount(url),
-      webviewUrl: url.toString()
-    });
-  }, [loadingTimeout, recoveryTimeout]);
-  const getMeta = react.useCallback(({
-    phase
-  }) => Object.assign(Object.assign({}, getSuccessMeta()), {
-    phase
-  }), [getSuccessMeta]);
+const useWebViewVisibility = core => {
+  const webViewVisibilityRequestChannelRef = react.useRef(messageTransport.createRequestChannel(core.messageTransport));
+  const [visible, setVisible] = react.useState(false);
+  react.useEffect(() => webViewVisibilityRequestChannelRef.current.handle('setVisibility', setVisible), [setVisible]);
   return {
-    getMeta,
-    getSuccessMeta,
-    recordEvent
+    visible
   };
 };
 
-/******************************************************************************
-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 styles = reactNative.StyleSheet.create({
+  container: {
+    backgroundColor: 'transparent',
+    bottom: 0,
+    flex: 1,
+    left: 0,
+    position: 'absolute',
+    right: 0,
+    top: 0,
+    width: '100%'
+  },
+  hide: {
+    elevation: 0,
+    opacity: 0,
+    zIndex: -10000
+  },
+  show: {
+    elevation: 10000,
+    opacity: 1,
+    zIndex: 10000
+  },
+  webview: {
+    backgroundColor: 'transparent',
+    flex: 1
+  }
 });
 
 const SUCCESS_LOG_COOLDOWN_MS = 60 * 60 * 1000;
@@ -455,225 +234,6 @@ const createSuccessLogCooldown = ({
   })
 });
 
-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 = react.useRef(false);
-  const getSuccessMetaRef = react.useRef(getSuccessMeta);
-  getSuccessMetaRef.current = getSuccessMeta;
-  react.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 !== webviewMessages.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 = react.useRef(messageTransport.createRequestChannel(core.messageTransport));
-  const [visible, setVisible] = react.useState(false);
-  react.useEffect(() => webViewVisibilityRequestChannelRef.current.handle('setVisibility', setVisible), [setVisible]);
-  return {
-    visible
-  };
-};
-
-const styles = reactNative.StyleSheet.create({
-  container: {
-    backgroundColor: 'transparent',
-    bottom: 0,
-    flex: 1,
-    left: 0,
-    position: 'absolute',
-    right: 0,
-    top: 0,
-    width: '100%'
-  },
-  hide: {
-    elevation: 0,
-    opacity: 0,
-    zIndex: -10000
-  },
-  show: {
-    elevation: 10000,
-    opacity: 1,
-    zIndex: 10000
-  },
-  webview: {
-    backgroundColor: 'transparent',
-    flex: 1
-  }
-});
-
-const setClearStateToUrl = webViewUrl => {
-  const newWebViewUrl = new URL(webViewUrl);
-  newWebViewUrl.searchParams.set(CLEAR_STATE_PARAM, 'true');
-  newWebViewUrl.searchParams.delete('retry');
-  return newWebViewUrl;
-};
-
-const useWebViewRecoveryTimeout = ({
-  core,
-  webViewUrl,
-  disableRecovery,
-  recoveryTimeout,
-  setWebViewUrl,
-  onFailedToLoadAfterClearState: _onFailedToLoadAfterClearState = () => {}
-}) => {
-  const timeoutRef = react.useRef(null);
-  const onFailedToLoadAfterClearStateRef = react.useRef(_onFailedToLoadAfterClearState);
-  onFailedToLoadAfterClearStateRef.current = _onFailedToLoadAfterClearState;
-  /**
-   * Clear timeout on unmount
-   */
-  react.useEffect(() => () => {
-    if (timeoutRef.current) {
-      clearTimeout(timeoutRef.current);
-      timeoutRef.current = null;
-    }
-  }, []);
-  return react.useCallback(() => {
-    if (disableRecovery) {
-      logger.debug('timeout recovery: is disabled');
-      return;
-    }
-    if (hasClearStateInUrl(webViewUrl)) {
-      logger.instrument('Webview failed to load after clearing its state', {
-        environmentId: core.environmentId,
-        hostSdkSessionId: core.hostSdkSessionId,
-        key: 'webview.failed_to_load_after_clear_state',
-        time: 0,
-        webviewUrl: webViewUrl.toString()
-      });
-      onFailedToLoadAfterClearStateRef.current();
-      return;
-    }
-    logger.debug('timeout recovery: registering timeout', webViewUrl.toString());
-    if (timeoutRef.current) {
-      clearTimeout(timeoutRef.current);
-    }
-    timeoutRef.current = setTimeout(() => {
-      if (!core.messageTransport.isBlocked()) {
-        logger.instrument('Webview recovery skipped because the webview did load', {
-          environmentId: core.environmentId,
-          hostSdkSessionId: core.hostSdkSessionId,
-          key: 'webview.recovery_skipped',
-          time: 0,
-          webviewUrl: webViewUrl.toString()
-        });
-        return;
-      }
-      core.messageTransport.block();
-      // Increase the retry
-      setWebViewUrl(webViewUrl => {
-        const newWebViewUrl = setClearStateToUrl(webViewUrl);
-        logger.instrument('timeout recovery: reloading webview to clear its state', {
-          environmentId: core.environmentId,
-          hostSdkSessionId: core.hostSdkSessionId,
-          key: 'webview.recovery_by_clear_state',
-          time: 0,
-          webviewUrl: webViewUrl.toString()
-        });
-        return newWebViewUrl;
-      });
-    }, recoveryTimeout);
-  }, [core, disableRecovery, recoveryTimeout, setWebViewUrl, webViewUrl]);
-};
-
-const increaseRetryToUrl = webViewUrl => {
-  var _a;
-  const currentRetry = Number((_a = webViewUrl.searchParams.get('retry')) !== null && _a !== void 0 ? _a : '0');
-  const newWebViewUrl = new URL(webViewUrl);
-  newWebViewUrl.searchParams.delete(CLEAR_STATE_PARAM);
-  newWebViewUrl.searchParams.set('retry', String(currentRetry + 1));
-  return newWebViewUrl;
-};
-
-const useWebViewLoadingTimeout = (timeout, onTimeout) => {
-  const timeoutRef = react.useRef(null);
-  const onTimeoutRef = react.useRef(onTimeout);
-  onTimeoutRef.current = onTimeout;
-  const onLoadStart = react.useCallback(() => {
-    if (timeoutRef.current) {
-      clearTimeout(timeoutRef.current);
-    }
-    timeoutRef.current = setTimeout(() => {
-      onTimeoutRef.current();
-    }, timeout);
-  }, [timeout]);
-  const onLoad = react.useCallback(() => {
-    if (timeoutRef.current) {
-      clearTimeout(timeoutRef.current);
-      timeoutRef.current = null;
-    }
-  }, []);
-  react.useEffect(() => () => {
-    if (timeoutRef.current) {
-      clearTimeout(timeoutRef.current);
-      timeoutRef.current = null;
-    }
-  }, []);
-  return {
-    onLoad,
-    onLoadStart
-  };
-};
-
-const assignEnvironmentIdToUrl = (url, environmentId) => {
-  const _url = new URL(url);
-  _url.searchParams.set(ENVIRONMENT_ID_PARAM, environmentId);
-  return _url;
-};
-
-const assignStartTimeToUrl = url => {
-  url.searchParams.set(WEBVIEW_START_TIME_PARAM, Date.now().toString());
-  return url;
-};
-
 const waasOrigins = ['https://app.dynamic-preprod.xyz', 'https://app.dynamicauth.com'];
 const turnkeyOrigins = ['https://recovery.turnkey.com', 'https://export.turnkey.com'];
 const isNonProductionBuild = () => process.env['NODE_ENV'] !== 'production';
@@ -708,158 +268,153 @@ const shouldAllowNavigation = (request, webViewUrl) => {
   return false;
 };
 
-const DEFAULT_RECOVERY_TIMEOUT_MS$1 = 20000;
-const DEFAULT_LOADING_TIMEOUT_MS$1 = 20000;
+const REACT_NATIVE_WEBVIEW_TYPE = 'react_native_webview';
+// react-native-webview's `onError` only carries a `domain` on iOS/macOS.
+// When it is absent (Android) this stable literal stands in so
+// `classifyWebViewLoadError` still receives a domain and classifies the
+// failure by its code alone (unknown domains default to transient).
+const REACT_NATIVE_WEBVIEW_LOAD_ERROR_DOMAIN = 'ReactNativeWebViewLoadError';
+const SUCCESS_LOG_COOLDOWN_STORAGE_KEY = 'dynamic.webview.successLogLastEmittedAt';
+// All load, timeout, retry, telemetry, and terminal-error logic is owned by
+// the webview load controller (`createWebViewLoadController`). This
+// component only owns the platform bindings: the react-native-webview
+// element, its lifecycle-event mapping, the message bridge, visibility
+// handling, and the navigation allowlist.
 const WebView = ({
-  webviewUrl: initialWebViewUrl,
+  webviewUrl,
   core,
   webviewDebuggingEnabled: _webviewDebuggingEnabled = false,
-  disableRecovery: _disableRecovery = false,
-  recoveryTimeout: _recoveryTimeout = DEFAULT_RECOVERY_TIMEOUT_MS$1,
-  loadingTimeout: _loadingTimeout = DEFAULT_LOADING_TIMEOUT_MS$1
+  recoveryTimeout,
+  loadingTimeout,
+  webviewLoad
 }) => {
   const webViewRef = react.useRef(null);
   const {
     visible
   } = useWebViewVisibility(core);
-  const [webViewUrl, setWebViewUrl] = react.useState(() => assignStartTimeToUrl(assignEnvironmentIdToUrl(initialWebViewUrl, core.environmentId)));
+  // The URL of the load attempt currently in flight. The controller owns
+  // URL construction (environmentId, start time, retry counter); loading a
+  // new URL remounts the webview via `key`, which is how reloads work on
+  // this path. `null` until the controller issues the first load.
+  const [currentAttemptUrl, setCurrentAttemptUrl] = react.useState(null);
+  const controllerRef = react.useRef(null);
   const {
     onMessageHandler
   } = useMessageTransportWebViewBridge(core, webViewRef);
-  const {
-    recordEvent,
-    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
+   * Owns the load-controller lifecycle: created once per mount, torn down
+   * on unmount (keeping the unmount warning + transport block so a stray
+   * unmount doesn't leave host messages hitting a dead page).
    */
-  react.useEffect(() => () => {
-    logger.warn(unmountWebViewWarningMessage);
-    core.messageTransport.block();
-  },
-  // eslint-disable-next-line react-hooks/exhaustive-deps -- we only care about the unmount callback
-  []);
-  const blockAndReloadWebView = react.useCallback(reason => {
-    /**
-     * Should not reload the webview if it is already blocked
-     * and loading a new page
-     */
-    if (core.messageTransport.isBlocked()) {
-      return;
-    }
-    /**
-     * iOS and Android both may trigger this event when the webview
-     * is removed due to memory pressure.
-     *
-     * When the webview is killed by the OS, the message transport must
-     * be blocked to prevent the "No handlers registered" error while
-     * the webview is reloading
-     */
-    core.messageTransport.block();
-    setWebViewUrl(webViewUrl => {
-      const newWebViewUrl = increaseRetryToUrl(webViewUrl);
-      logger.instrument('Reloading webview', {
-        environmentId: core.environmentId,
-        hostSdkSessionId: core.hostSdkSessionId,
-        key: 'webview.reloading',
-        newWebViewUrl,
-        reason,
-        time: 0,
-        webviewUrl: webViewUrl.toString()
-      });
-      return newWebViewUrl;
+  react.useEffect(() => {
+    const adapter = {
+      load: url => setCurrentAttemptUrl(url),
+      webviewType: REACT_NATIVE_WEBVIEW_TYPE
+    };
+    const successLogCooldown = createSuccessLogCooldown({
+      name: 'webview',
+      storageKey: SUCCESS_LOG_COOLDOWN_STORAGE_KEY
     });
-  }, [core]);
-  const blockAndReloadWebViewOsKill = react.useCallback(() => {
-    recordEvent('os_kill');
-    blockAndReloadWebView('os_kill');
-  }, [blockAndReloadWebView, recordEvent]);
-  react.useEffect(() => core.messageTransport.recoveryManager.onRecoveryRequested(() => blockAndReloadWebView('recovery')), [core, blockAndReloadWebView]);
-  const setWebViewLoadError = react.useCallback(phase => {
-    // Error was already thrown, do not throw again
-    if (core.initialization.error instanceof WebViewFailedToLoadError) return;
-    core.initialization.error = new WebViewFailedToLoadError(getMeta({
-      phase
+    const controller = client.createWebViewLoadController(Object.assign(Object.assign(Object.assign(Object.assign({
+      adapter,
+      core
+    }, webviewLoad), loadingTimeout !== undefined && {
+      pageLoadTimeoutMs: loadingTimeout
+    }), recoveryTimeout !== undefined && {
+      sdkReadyTimeoutMs: recoveryTimeout
+    }), {
+      // The controller exposes no post-emit hook, so the cooldown is
+      // recorded as soon as the gate passes — before the log leaves the
+      // device. Worst case (a teardown between gate and emit) one log is
+      // suppressed, which beats replaying it after a crash.
+      shouldEmitSuccessLog: () => __awaiter(void 0, void 0, void 0, function* () {
+        if (!(yield successLogCooldown.shouldEmit())) return false;
+        yield successLogCooldown.recordEmitted();
+        return true;
+      }),
+      webviewUrl
     }));
-  }, [core, getMeta]);
-  /**
-   * Wraps `setWebViewLoadError` so the consumer doesn't need to know
-   * about the phase enum; each callsite below binds its own phase.
-   */
-  const setWebViewLoadErrorWithPhase = react.useCallback(phase => () => setWebViewLoadError(phase), [setWebViewLoadError]);
+    controllerRef.current = controller;
+    // Hands the controller to the client core, which wires the
+    // customer-facing `client.sdk.loadState` / `client.sdk.retry()`
+    // surface to it.
+    core.registerWebViewLoadController(controller);
+    controller.start();
+    return () => {
+      logger.warn(unmountWebViewWarningMessage);
+      controller.teardown();
+      controllerRef.current = null;
+      core.messageTransport.block();
+    };
+    // eslint-disable-next-line react-hooks/exhaustive-deps -- the controller lifecycle is strictly mount/unmount
+  }, []);
+  const dispatch = event => {
+    var _a;
+    return (_a = controllerRef.current) === null || _a === void 0 ? void 0 : _a.dispatch(event);
+  };
+  const onError = ({
+    nativeEvent
+  }) => {
+    var _a;
+    return dispatch({
+      code: nativeEvent.code,
+      description: nativeEvent.description,
+      domain: (_a = nativeEvent.domain) !== null && _a !== void 0 ? _a : REACT_NATIVE_WEBVIEW_LOAD_ERROR_DOMAIN,
+      failedUrl: nativeEvent.url,
+      type: 'native_error'
+    });
+  };
+  const onHttpError = ({
+    nativeEvent
+  }) => dispatch({
+    code: nativeEvent.statusCode,
+    description: nativeEvent.description,
+    domain: client.EMBEDDED_WEBVIEW_HTTP_ERROR_DOMAIN,
+    failedUrl: nativeEvent.url,
+    type: 'native_error'
+  });
   /**
-   * Reload the webview with a clean state when a timeout is reached
-   * and the webview did not get to the loaded state yet
+   * iOS and Android both may kill the webview content process under memory
+   * pressure. The controller routes the signal through the bounded
+   * backed-off reload cycle, blocking the message transport while the
+   * reload is in flight (the machine handles it both mid-load and
+   * post-ready).
    */
-  const startRecoveryTimeout = useWebViewRecoveryTimeout({
-    core,
-    disableRecovery: _disableRecovery,
-    onFailedToLoadAfterClearState: setWebViewLoadErrorWithPhase('after_clear_state'),
-    recoveryTimeout: _recoveryTimeout,
-    setWebViewUrl,
-    webViewUrl
+  const onProcessTerminated = () => dispatch({
+    type: 'recovery_requested'
   });
-  const webViewLoadErrorCountRef = react.useRef(0);
-  const onWebViewLoadError = react.useCallback(() => {
-    webViewLoadErrorCountRef.current = webViewLoadErrorCountRef.current + 1;
-    recordEvent('native_error');
-    /**
-     * This is the first attempt to load the webview, do not throw an error
-     * because the recovery system will attempt to reload the webview
-     */
-    if (webViewLoadErrorCountRef.current === 1) return;
-    setWebViewLoadError('native_error');
-  }, [recordEvent, setWebViewLoadError]);
-  const {
-    onLoad: onLoadFromTimeout,
-    onLoadStart: onLoadStartFromTimeout
-  } = useWebViewLoadingTimeout(_loadingTimeout, setWebViewLoadErrorWithPhase('html_load'));
-  const onLoadStart = react.useCallback(() => {
-    recordEvent('load_start');
-    onLoadStartFromTimeout();
-  }, [onLoadStartFromTimeout, recordEvent]);
-  const onLoad = react.useCallback(() => {
-    recordEvent('load');
-    onLoadFromTimeout();
-  }, [onLoadFromTimeout, recordEvent]);
-  const onLoadEnd = react.useCallback(() => {
-    recordEvent('load_end');
-    startRecoveryTimeout();
-  }, [recordEvent, startRecoveryTimeout]);
-  const webViewUrlString = react.useMemo(() => webViewUrl.toString(), [webViewUrl]);
+  const containerStyles = [styles['container'], visible ? styles.show : styles.hide];
+  if (currentAttemptUrl === null) return null;
+  const currentAttemptUrlString = currentAttemptUrl.toString();
   return /*#__PURE__*/jsxRuntime.jsx(reactNativeWebview.WebView, {
     ref: webViewRef,
     source: {
-      uri: webViewUrlString
+      uri: currentAttemptUrlString
     },
     containerStyle: containerStyles,
     style: styles['webview'],
     onMessage: onMessageHandler,
-    onLoadEnd: onLoadEnd,
-    onLoadStart: onLoadStart,
-    onLoad: onLoad,
+    onLoadStart: () => dispatch({
+      type: 'load_started'
+    }),
+    onLoad: () => dispatch({
+      type: 'response_committed'
+    }),
+    onLoadEnd: () => dispatch({
+      type: 'page_finished'
+    }),
     hideKeyboardAccessoryView: true,
     webviewDebuggingEnabled: _webviewDebuggingEnabled,
-    onContentProcessDidTerminate: blockAndReloadWebViewOsKill,
-    onRenderProcessGone: blockAndReloadWebViewOsKill,
-    onError: onWebViewLoadError,
+    onContentProcessDidTerminate: onProcessTerminated,
+    onRenderProcessGone: onProcessTerminated,
+    onError: onError,
+    onHttpError: onHttpError,
     setSupportMultipleWindows: false,
     onShouldStartLoadWithRequest: request => shouldAllowNavigation({
       isTopFrame: request.isTopFrame,
       url: request.url
-    }, webViewUrl)
-  }, webViewUrlString);
+    }, currentAttemptUrl)
+  }, currentAttemptUrlString);
 };
 const createWebView = internalProps => {
   const WebViewWrapper = props => /*#__PURE__*/jsxRuntime.jsx(WebView, _extends({}, internalProps, props));
@@ -918,53 +473,10 @@ const getEmbeddedWebView = () => {
   }
 };
 
-/**
- * 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.
- *
- * 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,
-  loadingTimeoutMs,
-  recoveryTimeoutMs,
-  webViewUrl
-}) => {
-  const phaseCore = createWebViewPhaseTimerCore({
-    core
-  });
-  const getSuccessMeta = () => buildSuccessMeta({
-    core: phaseCore,
-    hadClearState: false,
-    loadingTimeoutMs,
-    recoveryTimeoutMs,
-    retryCount: 0,
-    webviewUrl: webViewUrl.toString()
-  });
-  return {
-    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;
+// The platform discriminator the load controller attaches to every
+// consolidated `webview.load_*` telemetry event emitted for this path.
+const EMBEDDED_WEBVIEW_TYPE = 'embedded_native';
 // Debug log labels matching the react-native-webview bridge
 // (`useMessageTransportWebViewBridge`) so both paths surface the same
 // HOST/WEBVIEW message trace under `core.debug.messageTransport`.
@@ -975,6 +487,11 @@ const WEBVIEW_TO_HOST_LOG = 'WEBVIEW >>>> HOST';
 // outside the React tree (in a dedicated UIWindow on iOS), so its setup runs
 // once when the SDK is initialised — there's nothing to mount or unmount.
 //
+// All load, timeout, retry, telemetry, and terminal-error logic is owned by
+// the webview load controller (`createWebViewLoadController`). This module
+// only owns the platform bindings: the native-module wiring, the message
+// bridge, visibility handling, and the navigation allowlist.
+//
 // Returns a teardown that removes every JS-side subscription. The native
 // singleton is intentionally NOT destroyed — re-running setup with a fresh
 // `core` (e.g. on client recreation with a new environmentId) just reloads
@@ -983,61 +500,48 @@ const setupEmbeddedWebView = ({
   webviewUrl,
   core,
   webviewDebuggingEnabled: _webviewDebuggingEnabled = false,
-  loadingTimeoutMs: _loadingTimeoutMs = DEFAULT_LOADING_TIMEOUT_MS,
-  recoveryTimeoutMs: _recoveryTimeoutMs = DEFAULT_RECOVERY_TIMEOUT_MS
+  webviewLoad
 }) => {
   const native = getEmbeddedWebView();
-  const builtUrl = assignStartTimeToUrl(assignEnvironmentIdToUrl(webviewUrl, core.environmentId));
-  const phaseTimers = createEmbeddedWebViewPhaseTimers({
-    core,
-    loadingTimeoutMs: _loadingTimeoutMs,
-    recoveryTimeoutMs: _recoveryTimeoutMs,
-    webViewUrl: builtUrl
-  });
+  // The URL of the load attempt currently in flight. The controller owns
+  // URL construction (environmentId, start time, retry counter), so the
+  // navigation allowlist below must compare against the URL the native
+  // webview was actually pointed at. Until the first `adapter.load` the
+  // base URL stands in — only its origin is ever compared.
+  let currentAttemptUrl = new URL(webviewUrl);
+  const adapter = {
+    load: url => {
+      var _a;
+      currentAttemptUrl = url;
+      logger.debug(`[EmbeddedWebView] calling setUrl: ${url.toString()}`);
+      (_a = native.setUrl(url.toString())) === null || _a === void 0 ? void 0 : _a.catch(err => {
+        logger.warn('EmbeddedWebView.setUrl failed', err);
+      });
+    },
+    webviewType: EMBEDDED_WEBVIEW_TYPE
+  };
   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;
-  let tornDown = false;
-  const clearLoadingTimer = () => {
-    if (loadingTimer !== null) {
-      clearTimeout(loadingTimer);
-      loadingTimer = null;
-    }
-  };
-  const clearRecoveryTimer = () => {
-    if (recoveryTimer !== null) {
-      clearTimeout(recoveryTimer);
-      recoveryTimer = null;
-    }
-  };
-  // Raise `WebViewFailedToLoadError` once per setup. Subsequent triggers
-  // (e.g. recovery timeout firing after html_load already failed) are
-  // suppressed so we don't spam the initialization-error setter with
-  // duplicate logs for the same load attempt.
-  const raiseFailure = (phase, extraMeta = {}) => {
-    if (hasFailed) return;
-    hasFailed = true;
-    clearLoadingTimer();
-    clearRecoveryTimer();
-    logger.debug(`[EmbeddedWebView] raiseFailure phase=${phase}`);
-    const meta = phaseTimers.getMeta({
-      phase
-    });
-    logger.instrument('Embedded webview load error', Object.assign({
-      environmentId: core.environmentId,
-      hostSdkSessionId: core.hostSdkSessionId,
-      key: 'webview.embedded.load_error',
-      phase,
-      time: 0,
-      webviewUrl: builtUrl.toString()
-    }, extraMeta));
-    core.initialization.error = new WebViewFailedToLoadError(Object.assign(Object.assign({}, meta), extraMeta));
-  };
+  const controller = client.createWebViewLoadController(Object.assign(Object.assign({
+    adapter,
+    core
+  }, webviewLoad), {
+    // The controller exposes no post-emit hook, so the cooldown is recorded
+    // as soon as the gate passes — before the log leaves the device. Worst
+    // case (a teardown between gate and emit) one log is suppressed, which
+    // beats replaying it after a crash.
+    shouldEmitSuccessLog: () => __awaiter(void 0, void 0, void 0, function* () {
+      if (!(yield successLogCooldown.shouldEmit())) return false;
+      yield successLogCooldown.recordEmitted();
+      return true;
+    }),
+    webviewUrl
+  }));
+  // Hands the controller to the client core, which wires the customer-facing
+  // `client.sdk.loadState` / `client.sdk.retry()` surface to it.
+  core.registerWebViewLoadController(controller);
   const visibilityChannel = messageTransport.createRequestChannel(core.messageTransport);
   const removeVisibilityHandler = visibilityChannel.handle('setVisibility', visible => {
     native.setVisible(visible).catch(err => {
@@ -1055,31 +559,6 @@ const setupEmbeddedWebView = ({
     });
   };
   core.messageTransport.on(handleHostMessage);
-  // Watch for the webview-side SDK ready signal so we can clear the
-  // 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 !== webviewMessages.sdkHasLoadedEventName) return;
-    logger.debug('[EmbeddedWebView] SDK ready signal received');
-    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 => {
     var _a;
     let parsed = null;
@@ -1101,7 +580,7 @@ const setupEmbeddedWebView = ({
     const allow = shouldAllowNavigation({
       isTopFrame: event.isTopFrame,
       url: event.url
-    }, builtUrl);
+    }, currentAttemptUrl);
     logger.debug(`[EmbeddedWebView] onShouldStartLoad id=${event.id} url=${event.url} isTopFrame=${event.isTopFrame} allow=${allow}`);
     native.respondToShouldStartLoad(event.id, allow).catch(err => {
       logger.warn('EmbeddedWebView.respondToShouldStartLoad failed', err);
@@ -1109,86 +588,57 @@ const setupEmbeddedWebView = ({
   });
   const onLoadStartSub = native.addListener('onLoadStart', () => {
     logger.debug('[EmbeddedWebView] onLoadStart');
-    phaseTimers.recordEvent('load_start');
-    // Re-arm both timers on every load_start. A retry from the native
-    // side (e.g. a redirect, or a reload after a transient failure)
-    // resets the html_load window cleanly without leaving a stale timer
-    // around from the previous attempt.
-    clearLoadingTimer();
-    clearRecoveryTimer();
-    loadingTimer = setTimeout(() => {
-      raiseFailure('html_load');
-    }, _loadingTimeoutMs);
+    controller.dispatch({
+      type: 'load_started'
+    });
   });
   const onLoadSub = native.addListener('onLoad', () => {
     logger.debug('[EmbeddedWebView] onLoad (response committed)');
-    phaseTimers.recordEvent('load');
-    clearLoadingTimer();
+    controller.dispatch({
+      type: 'response_committed'
+    });
   });
   const onLoadEndSub = native.addListener('onLoadEnd', () => {
     logger.debug('[EmbeddedWebView] onLoadEnd (page finished)');
-    phaseTimers.recordEvent('load_end');
-    clearLoadingTimer();
-    clearRecoveryTimer();
-    recoveryTimer = setTimeout(() => {
-      raiseFailure('sdk_bootstrap');
-    }, _recoveryTimeoutMs);
+    controller.dispatch({
+      type: 'page_finished'
+    });
   });
   const onLoadErrorSub = native.addListener('onLoadError', event => {
     logger.debug(`[EmbeddedWebView] onLoadError domain=${event.domain} code=${event.code} url=${event.url}`);
-    phaseTimers.recordEvent('native_error');
     logger.warn('EmbeddedWebView load error', event);
-    raiseFailure('embedded_native_error', {
-      nativeErrorCode: event.code,
-      nativeErrorDescription: event.description,
-      nativeErrorDomain: event.domain,
-      nativeErrorFailedUrl: event.url,
-      nativeErrorIsProvisional: event.isProvisional
+    controller.dispatch({
+      code: event.code,
+      description: event.description,
+      domain: event.domain,
+      failedUrl: event.url,
+      isProvisional: event.isProvisional,
+      type: 'native_error'
     });
   });
   native.setDebuggingEnabled(_webviewDebuggingEnabled).catch(err => {
     logger.warn('EmbeddedWebView.setDebuggingEnabled failed', err);
   });
-  // Arm the loading timer before calling setUrl so the pre-onLoadStart window
-  // is covered. On cold boot the native 2s navigation-decision timeout can
-  // fire before JS responds to onShouldStartLoad, silently cancelling the load
-  // without emitting onLoadError — leaving onLoadStart (and therefore the
-  // timer) never triggered. The onLoadStart handler clears and re-arms this
-  // timer when it fires, so behaviour after onLoadStart is unchanged.
-  logger.debug(`[EmbeddedWebView] arming loading timer (${_loadingTimeoutMs}ms) before setUrl`);
-  loadingTimer = setTimeout(() => {
-    logger.debug('[EmbeddedWebView] loading timer fired — raising html_load failure');
-    raiseFailure('html_load');
-  }, _loadingTimeoutMs);
-  // Defer setUrl by one event-loop tick so the JS thread has fully settled
-  // after listener registration. On cold boot the main thread is congested
-  // with bundle evaluation — yielding here gives pending microtasks and
-  // native bridge batches a chance to flush before the native side starts
+  // Defer the initial load by one event-loop tick so the JS thread has fully
+  // settled after listener registration. On cold boot the main thread is
+  // congested with bundle evaluation — yielding here gives pending microtasks
+  // and native bridge batches a chance to flush before the native side starts
   // firing navigation events that require a JS round-trip response.
   const warmupTimer = setTimeout(() => {
-    var _a;
-    if (tornDown) return;
-    logger.debug(`[EmbeddedWebView] calling setUrl: ${builtUrl.toString()}`);
-    (_a = native.setUrl(builtUrl.toString())) === null || _a === void 0 ? void 0 : _a.catch(err => {
-      logger.warn('EmbeddedWebView.setUrl failed', err);
-    });
+    controller.start();
   }, 0);
   return () => {
     logger.debug('[EmbeddedWebView] teardown — removing listeners');
-    tornDown = true;
     clearTimeout(warmupTimer);
-    clearLoadingTimer();
-    clearRecoveryTimer();
+    controller.teardown();
     removeVisibilityHandler();
     core.messageTransport.off(handleHostMessage);
-    core.messageTransport.off(handleSdkReady);
     onMessageSub.remove();
     onShouldStartLoadSub.remove();
     onLoadStartSub.remove();
     onLoadSub.remove();
     onLoadEndSub.remove();
     onLoadErrorSub.remove();
-    phaseTimers.dispose();
   };
 };
 
@@ -1532,7 +982,8 @@ const ReactNativeExtension = ({
   webviewUrl: _webviewUrl = defaultWebviewUrl,
   webviewDebuggingEnabled,
   appOrigin,
-  embeddedWebView: _embeddedWebView = false
+  embeddedWebView: _embeddedWebView = false,
+  webviewLoad
 } = {}) => (_, core) => {
   const isPlatformSupportedByWebView = reactNative.Platform.OS === 'android' || reactNative.Platform.OS === 'ios';
   /**
@@ -1583,6 +1034,7 @@ const ReactNativeExtension = ({
       previousEmbeddedWebViewTeardown = setupEmbeddedWebView({
         core,
         webviewDebuggingEnabled,
+        webviewLoad,
         webviewUrl: _webviewUrl
       });
     } catch (err) {
@@ -1603,6 +1055,7 @@ const ReactNativeExtension = ({
       WebView: createWebView({
         core,
         webviewDebuggingEnabled,
+        webviewLoad,
         webviewUrl: _webviewUrl
       })
     }
@@ -1611,5 +1064,8 @@ const ReactNativeExtension = ({
 
 assertPackageVersion.assertPackageVersion('@dynamic-labs/react-native-extension', version);
 
+Object.defineProperty(exports, 'WebViewFailedToLoadError', {
+  enumerable: true,
+  get: function () { return client.WebViewFailedToLoadError; }
+});
 exports.ReactNativeExtension = ReactNativeExtension;
-exports.WebViewFailedToLoadError = WebViewFailedToLoadError;