@onekeyfe/react-native-chart-webview 3.0.61 → 3.0.63

package/ChartWebview.podspec

@@ -21,9 +21,6 @@ Pod::Spec.new do |s|
 
   s.dependency 'React-jsi'
   s.dependency 'React-callinvoker'
-  # DEBUG instrumentation: route native chart lifecycle logs into the shared
-  # OneKeyLog file (app-latest.log) via `import ReactNativeNativeLogger`.
-  s.dependency 'ReactNativeNativeLogger'
 
   load 'nitrogen/generated/ios/ChartWebview+autolinking.rb'
   add_nitrogen_files(s)

package/android/src/main/java/com/margelo/nitro/chartwebview/ChartWebview.kt

@@ -98,46 +98,34 @@ class HybridChartWebview(val context: ThemedReactContext) : HybridChartWebviewSp
 
   // --- Source props ---
 
-  // Source/bridge setters call applySource (synchronous) — NOT scheduleReconcile,
-  // which caused an infinite reconcile loop (reconcile -> setSource -> prop
-  // re-apply -> reconcile ...). applySource sets warmDriver + warm-boots the page
-  // even when this host is not the visible owner, so post-attach bridge arrival
-  // still makes this host the warm driver (page->native callbacks fall back to it).
   private var _uri: String? = null
   override var uri: String?
     get() = _uri
-    set(value) { _uri = value; applySource() }
+    set(value) { _uri = value; applySourceIfOwner() }
 
   private var _localBundle: String? = null
   override var localBundle: String?
     get() = _localBundle
-    set(value) { _localBundle = value; applySource() }
+    set(value) { _localBundle = value; applySourceIfOwner() }
 
   private var _entry: String? = null
   override var entry: String?
     get() = _entry
-    set(value) { _entry = value; applySource() }
+    set(value) { _entry = value; applySourceIfOwner() }
 
   private var _paramsJson: String? = null
   override var paramsJson: String?
     get() = _paramsJson
-    set(value) { _paramsJson = value; applySource() }
-
-  // ANDROID: the host the offline `localBundle` is served under. When set, the
-  // offline bundle is served from https://<assetHost>/ so the WebView reuses the
-  // real chart origin's same-origin storage (zero migration). Falls back to the
-  // built-in appassets host in the pool when null. (iOS ignores this prop.)
-  private var _assetHost: String? = null
-  override var assetHost: String?
-    get() = _assetHost
-    set(value) { _assetHost = value; applySource() }
+    set(value) { _paramsJson = value; applySourceIfOwner() }
 
   // Document-start bridge JS (single source of truth in the TS layer). Stored and
   // handed to the pooled WebView when we claim it, before its first load.
   private var _bridgeScript: String? = null
   override var bridgeScript: String?
     get() = _bridgeScript
-    set(value) { _bridgeScript = value; applySource() }
+    // Re-apply the source: if this prop lands after the source props (a load can't
+    // run before the bridge is registered, so setSource deferred), this triggers it.
+    set(value) { _bridgeScript = value; applySourceIfOwner() }
 
   // --- Singleton props ---
   // `pooled` + non-empty `reuseKey` => the backing WebView is shared (keyed by
@@ -174,22 +162,6 @@ class HybridChartWebview(val context: ThemedReactContext) : HybridChartWebviewSp
       scheduleReconcile()
     }
 
-  // --- Debugging ---
-  // Make the backing WebView inspectable via chrome://inspect. Driven by the
-  // app's "Enable Native Webview Debugging" dev-mode toggle, mirroring the main
-  // react-native-webview (which calls WebView.setWebContentsDebuggingEnabled).
-  // Stored and applied to the backing WebView both here (on prop change) and at
-  // host claim, since `backing` is null until the first reconcile assigns it.
-  // CAVEAT: setWebContentsDebuggingEnabled is PROCESS-GLOBAL — see
-  // PooledChartWebView.setInspectable.
-  private var _webviewDebuggingEnabled: Boolean? = null
-  override var webviewDebuggingEnabled: Boolean?
-    get() = _webviewDebuggingEnabled
-    set(value) {
-      _webviewDebuggingEnabled = value
-      backing?.setInspectable(value)
-    }
-
   // --- Event callbacks ---
   override var onMessage: ((message: String) -> Unit)? = null
   override var onLoadEnd: (() -> Unit)? = null
@@ -247,9 +219,6 @@ class HybridChartWebview(val context: ThemedReactContext) : HybridChartWebviewSp
     val key = effectiveKey()
     val entry = ChartWebviewPool.acquireShared(key, context)
     backing = entry
-    // Apply this host's debug preference to the (possibly freshly created) backing
-    // WebView. Mirrors the main react-native-webview's setWebContentsDebuggingEnabled.
-    entry.setInspectable(_webviewDebuggingEnabled)
     // Refcount the pool entry once per host (reconcile runs many times). Balanced
     // by releaseShared in dispose(). If the reuseKey changed, release the old one.
     if (adoptedPoolKey != key) {
@@ -257,24 +226,13 @@ class HybridChartWebview(val context: ThemedReactContext) : HybridChartWebviewSp
       ChartWebviewPool.adopt(key)
       adoptedPoolKey = key
     }
-    // WARM-BOOT (mirror of iOS): boot the shared offline page + register as the
-    // warm DRIVER as soon as ANY referencing host has the bridge, even when not
-    // the visible owner (offscreen prewarm runs with attached=false/active=false).
-    // page->native callbacks fall back to warmDriver when there's no owner, so the
-    // bars-state / load-end signals aren't dropped during warm — otherwise the
-    // chart stays on the loading mask. Idempotent: setSource dedupes on same URL,
-    // setBridgeScript no-ops once registered.
-    val bs = _bridgeScript
-    if (!bs.isNullOrEmpty()) {
-      entry.setBridgeScript(bs)
-      entry.warmDriver = this
-      entry.setSource(_uri, _localBundle, _entry, _paramsJson, _assetHost)
-    }
     if (wantsOwnership()) {
       entry.owner = this
-      // PERF: a host is now showing the chart — make sure the renderer is running.
-      entry.resume()
+      // Register the document-start bridge before the first load (the prop is set
+      // by now; the pool may have been created earlier by a window-attach reconcile).
+      entry.setBridgeScript(_bridgeScript ?: "")
       entry.attachTo(container)
+      entry.setSource(_uri, _localBundle, _entry, _paramsJson)
       // Keep a fresh frame of OUR content while we own the WebView, so that when
       // we later go inactive (and the shared WebView reloads the other slot's
       // chart) our slot freezes to its own last frame, not the other content.
@@ -290,11 +248,6 @@ class HybridChartWebview(val context: ThemedReactContext) : HybridChartWebviewSp
       if (wasOwner) entry.owner = null
       stopOwnCapture()
       showPlaceholder(ownSnapshot)
-      // PERF: if nobody owns the shared WebView now, pause its renderer so it
-      // doesn't keep burning a CPU core + GPU + RAM in the background (Android
-      // doesn't auto-throttle offscreen WebViews like iOS does). Resumed on the
-      // next CLAIM. No-op until the page's first load completed.
-      entry.pauseIfIdle()
     }
   }
 
@@ -304,30 +257,19 @@ class HybridChartWebview(val context: ThemedReactContext) : HybridChartWebviewSp
     if (!wantsOwnership()) return
     val pooled = backing ?: PooledChartWebView.create(context, effectiveKey())
     backing = pooled
-    pooled.setInspectable(_webviewDebuggingEnabled)
     pooled.owner = this
     pooled.setBridgeScript(_bridgeScript ?: "")
     pooled.attachTo(container)
-    pooled.setSource(_uri, _localBundle, _entry, _paramsJson, _assetHost)
+    pooled.setSource(_uri, _localBundle, _entry, _paramsJson)
   }
 
-  // Apply the source synchronously when a source/bridge prop changes. For a
-  // pooled host this ALSO registers it as the warmDriver and warm-boots the page
-  // even when it is not the visible owner, so page->native callbacks (bars-state /
-  // load-end) fall back to it when no host owns the pool. No scheduleReconcile —
-  // that looped. backing is null until the first reconcile assigns it (the
-  // reuseKey/pooled/active setters still scheduleReconcile), so warmDriver is set
-  // on the first prop change after the pool entry is acquired.
-  private fun applySource() {
+  private fun applySourceIfOwner() {
     val pooled = backing ?: return
-    val bs = _bridgeScript
-    if (isPooled() && !bs.isNullOrEmpty()) {
-      pooled.setBridgeScript(bs)
-      pooled.warmDriver = this
-      pooled.setSource(_uri, _localBundle, _entry, _paramsJson, _assetHost)
-    } else if (pooled.owner == this) {
+    if (pooled.owner == this) {
+      // Register the bridge before any load setSource may trigger (setSource
+      // defers loading until the bridge is registered).
       pooled.setBridgeScript(_bridgeScript ?: "")
-      pooled.setSource(_uri, _localBundle, _entry, _paramsJson, _assetHost)
+      pooled.setSource(_uri, _localBundle, _entry, _paramsJson)
     }
   }
 
@@ -417,7 +359,7 @@ class HybridChartWebview(val context: ThemedReactContext) : HybridChartWebviewSp
   // WebView so it doesn't leak a Chromium renderer + JavascriptInterface per
   // mount/unmount. Pooled (shared) backing is intentionally left alive in the
   // warm pool — other hosts may still share it; its lifetime is the pool's.
-  override fun dispose() {
+  fun dispose() {
     stopOwnCapture()
     container.removeCallbacks(reconcileRunnable)
     container.removeCallbacks(revealFallbackRunnable)
@@ -426,19 +368,10 @@ class HybridChartWebview(val context: ThemedReactContext) : HybridChartWebviewSp
     if (pendingRevealHost == this) pendingRevealHost = null
     val entry = backing
     if (entry != null && entry.owner == this) entry.owner = null
-    if (entry != null && entry.warmDriver == this) entry.warmDriver = null
     // Balance the pool adopt() if this host ever joined a pooled key. Kept warm by
     // default (single-instance cache); the release path makes destroy() reachable.
     adoptedPoolKey?.let { ChartWebviewPool.releaseShared(it) }
     adoptedPoolKey = null
-    // Pooled host going away: release the shared WebView from THIS host's
-    // container, which is about to be dropped from the view tree. The pool keeps
-    // the WebView alive (warm) for the next host, but if we leave it parented to
-    // our dropped container the next host's attach can't clear that stale parent
-    // (removeView on a detached container isn't applied synchronously) and retries
-    // forever → blank/white chart. detachFrom is parent-checked, so if another host
-    // already re-claimed the WebView we leave it where it is.
-    if (entry != null && isPooled()) entry.detachFrom(container)
     // A private (non-pooled) instance is owned solely by this host — tear it down
     // so it doesn't leak a Chromium renderer + JavascriptInterface.
     if (entry != null && !isPooled()) entry.destroy()

package/android/src/main/java/com/margelo/nitro/chartwebview/PooledChartWebView.kt

@@ -25,7 +25,6 @@ import androidx.webkit.WebViewClientCompat
 import androidx.webkit.WebViewCompat
 import androidx.webkit.WebViewFeature
 import org.json.JSONObject
-import java.lang.ref.WeakReference
 import java.net.URLEncoder
 import java.util.concurrent.atomic.AtomicInteger
 
@@ -53,9 +52,6 @@ class PooledChartWebView private constructor(
     const val ASSET_HOST = "appassets.androidplatform.net"
     private const val DEFAULT_ENTRY = "index.html"
 
-    // Operational log tag for this pool (lifecycle + error paths only).
-    private const val TAG = "ChartWebviewPool"
-
     // Tiny platform transport shim: defines the single hook the shared TS bridge
     // (CHART_BRIDGE_JS) calls. The bulk of the bridge lives in the TS layer and
     // arrives via the `bridgeScript` ctor arg — this is the only platform-specific
@@ -127,12 +123,12 @@ class PooledChartWebView private constructor(
   }
 
   // The trusted origin set for the current source: the offline asset origin
-  // (https://<assetHost>, default appassets.androidplatform.net) always, plus the
-  // online/fallback `uri` origin when running in online mode. computeTargetUrl
-  // serves offline content from `assetHost` and online content from `uri`, so
-  // these are exactly the origins the privileged bridge legitimately runs in.
+  // (https://appassets.androidplatform.net) always, plus the online/fallback
+  // `uri` origin when running in online mode. computeTargetUrl serves offline
+  // content from ASSET_HOST and online content from `uri`, so these are exactly
+  // the origins the privileged bridge legitimately runs in.
   private fun trustedOriginsFor(uri: String?): Set<String> {
-    val origins = linkedSetOf("https://$assetHost")
+    val origins = linkedSetOf("https://$ASSET_HOST")
     originOf(uri)?.let { origins.add(it) }
     return origins
   }
@@ -152,78 +148,11 @@ class PooledChartWebView private constructor(
   }
 
   /** The host currently displaying this WebView; page events route here. */
-  // Weak (mirror of iOS): the pool entry is immortal, so a strong ref here would
-  // pin a disposed host — and its ReactContext/Activity — forever. A GC'd host
-  // reads back as null, which makes `entry.owner == this` correctly false.
-  private var _ownerRef: WeakReference<HybridChartWebview>? = null
-  var owner: HybridChartWebview?
-    get() = _ownerRef?.get()
-    set(value) {
-      _ownerRef = value?.let { WeakReference(it) }
-    }
-  // The host that warm-booted the page and can drive its symbol / receive its
-  // callbacks while there is no VISIBLE owner yet. Separate from `owner` (the
-  // YIELD path clears `owner`); callbacks fall back to this so bars-state /
-  // load-end aren't dropped during warm. Mirror of the iOS warmDriver.
-  // Weak for the same immortal-pool reason as `owner` above.
-  private var _warmDriverRef: WeakReference<HybridChartWebview>? = null
-  var warmDriver: HybridChartWebview?
-    get() = _warmDriverRef?.get()
-    set(value) {
-      _warmDriverRef = value?.let { WeakReference(it) }
-    }
-
-  // PERF (Android only): Android's in-process WebView/Chromium does NOT throttle
-  // an offscreen/unowned page (unlike iOS WKWebView). Left running, the warm
-  // pooled page keeps its rAF render loop + websockets + compositing alive
-  // FOREVER after the user leaves the chart — pinning a CPU core, growing RAM to
-  // OOM, and stealing the GPU from RN's RenderThread (every other screen stalls).
-  // We pause the WebView whenever no host owns it (after the first load) and
-  // resume on claim. Uses the PER-INSTANCE onPause()/onResume() — NOT the static
-  // pauseTimers()/resumeTimers(), which are process-global and would also freeze
-  // the app's other WebViews (inpage provider / web-embed / dapp browser).
-  private var paused = false
-  private var hasLoadedOnce = false
-
-  fun markLoaded() {
-    hasLoadedOnce = true
-  }
-
-  // Pause the renderer when nobody owns the shared WebView. onPause() stops
-  // drawing/compositing/animations (frees the GPU so navigation is smooth again)
-  // WITHOUT changing the view's visibility/attachment — we must NOT toggle
-  // visibility here, that left the WebView blank/white after re-claim. Skipped
-  // until the first load so we never freeze a booting page. Resumed (+ redraw)
-  // on the next CLAIM so the chart paints again.
-  fun pauseIfIdle() {
-    if (paused || !hasLoadedOnce || owner != null) {
-      return
-    }
-    paused = true
-    android.util.Log.d(TAG, "pool[$key] PAUSE (renderer idle)")
-    runOnUiThread { webView.onPause() }
-  }
-
-  fun resume() {
-    if (!paused) return
-    paused = false
-    android.util.Log.d(TAG, "pool[$key] RESUME")
-    runOnUiThread {
-      webView.onResume()
-      webView.invalidate()
-    }
-  }
+  var owner: HybridChartWebview? = null
 
   private var assetLoader: WebViewAssetLoader? = null
   private var lastLoadedUrl: String? = null
   private var lastLocalBundle: String? = null
-  // The host the offline bundle is served under. Defaults to the built-in
-  // appassets host (old behavior); when the app passes `assetHost` we serve the
-  // bundle under the real chart origin so the WebView reuses that origin's
-  // same-origin storage (zero migration). Tracked so an assetHost change rebuilds
-  // the asset loader + recomputes the target URL, same as a localBundle change.
-  private var assetHost: String = ASSET_HOST
-  private var lastAssetHost: String = ASSET_HOST
 
   // Last rendered frame, used to mask the brief blank frame while the WebView's
   // surface is torn down and recreated during a reparent (move). Kept until
@@ -238,9 +167,6 @@ class PooledChartWebView private constructor(
   // How long the snapshot overlay stays up after a reparent, giving the WebView
   // time to draw its first frame in the new container (~5 frames).
   private val overlayHideDelayMs = 80L
-  // Delay between bounded attach retries (~1 vsync at 60Hz): long enough for the
-  // old parent's pending layout / removeView to flush, short enough to stay snappy.
-  private val attachRetryDelayMs = 16L
   private val attachGeneration = AtomicInteger(0)
 
   val webView: WebView = WebView(context).apply {
@@ -253,28 +179,9 @@ class PooledChartWebView private constructor(
     addJavascriptInterface(ChartBridge(), "AndroidChartBridge")
   }
 
-  // Apply the app's "Enable Native Webview Debugging" dev-mode toggle, mirroring
-  // how the main react-native-webview calls WebView.setWebContentsDebuggingEnabled.
-  // Called by the host both on the prop change and at host claim, so the toggle is
-  // honored even when this entry was created before the prop arrived.
-  //
-  // CAVEAT (PROCESS-GLOBAL): setWebContentsDebuggingEnabled is a STATIC method that
-  // flips remote-debugging for EVERY WebView in the whole process. Once any WebView
-  // (this chart, the main react-native-webview, etc.) enables it, it stays enabled
-  // process-wide until the app is killed — Android exposes no per-WebView toggle and
-  // no way to read the current value. So a null/false preference here cannot turn
-  // debugging back OFF once another WebView (or a prior true value) turned it ON; it
-  // simply does not re-enable it. We therefore only ever call the setter with `true`
-  // when explicitly enabled, leaving the process-global state untouched otherwise.
-  fun setInspectable(enabled: Boolean?) {
-    if (enabled == true) {
-      runOnUiThread { WebView.setWebContentsDebuggingEnabled(true) }
-    }
-  }
-
   init {
     val n = liveCount.incrementAndGet()
-    android.util.Log.d(TAG, "WebView CREATED key=$key liveCount=$n")
+    android.util.Log.d("ChartWebviewPool", "WebView CREATED key=$key liveCount=$n")
 
     webView.webViewClient = object : WebViewClientCompat() {
       override fun shouldInterceptRequest(
@@ -284,12 +191,11 @@ class PooledChartWebView private constructor(
 
       override fun onPageFinished(view: WebView, url: String?) {
         super.onPageFinished(view, url)
-        markLoaded()
         // The bridge is delivered exclusively via the origin-scoped document-start
         // script (see registerBridgeForOrigins). We deliberately do NOT re-inject
         // it here via evaluateJavascript — that ran on every page event regardless
         // of URL and would expose the privileged bridge to untrusted pages/frames.
-        (owner ?: warmDriver)?.dispatchLoadEnd()
+        owner?.dispatchLoadEnd()
         // Prime the snapshot so the first move already has a frame to mask with.
         refreshSnapshotSoon()
       }
@@ -311,34 +217,7 @@ class PooledChartWebView private constructor(
   private inner class ChartBridge {
     @JavascriptInterface
     fun postMessage(message: String) {
-      runOnUiThread {
-        val target = owner ?: warmDriver
-        target?.dispatchMessage(message)
-      }
-    }
-  }
-
-  // Robustly detach the WebView from [parent], even when [parent] is a disposed
-  // host container that is mid-teardown / detached from the window and holds the
-  // child in a transition / disappearing-children list — where a plain removeView()
-  // is deferred and leaves webView.parent set, stranding the shared WebView and
-  // blanking the next chart slot. endViewTransition() clears any pending transition
-  // hold; removeViewInLayout() is the in-layout fallback if the child is still held.
-  private fun forceDetach(parent: ViewGroup) {
-    if (webView.parent !== parent) return
-    try {
-      parent.endViewTransition(webView)
-    } catch (e: Throwable) {
-      android.util.Log.w(TAG, "forceDetach: endViewTransition failed", e)
-    }
-    parent.removeView(webView)
-    if (webView.parent === parent) {
-      try {
-        parent.removeViewInLayout(webView)
-      } catch (e: Throwable) {
-        android.util.Log.w(TAG, "forceDetach: removeViewInLayout failed", e)
-      }
-      parent.requestLayout()
+      runOnUiThread { owner?.dispatchMessage(message) }
     }
   }
 
@@ -346,42 +225,24 @@ class PooledChartWebView private constructor(
   fun attachTo(container: ViewGroup) {
     val generation = attachGeneration.incrementAndGet()
     runOnUiThread {
-      attachToContainer(container, generation, retriesLeft = 12)
+      attachToContainer(container, generation, canRetry = true)
     }
   }
 
-  private fun attachToContainer(container: ViewGroup, generation: Int, retriesLeft: Int) {
+  private fun attachToContainer(container: ViewGroup, generation: Int, canRetry: Boolean) {
     if (generation != attachGeneration.get()) return
     if (webView.parent === container) return
 
-    (webView.parent as? ViewGroup)?.let { forceDetach(it) }
+    (webView.parent as? ViewGroup)?.removeView(webView)
     val currentParent = webView.parent
-    if (currentParent != null && currentParent !== container) {
-      // The old container still hasn't released the WebView (a disposed host's
-      // container mid-teardown / detached from window: removeView is deferred and
-      // getParent() stays set). Retry — but on the TARGET container's handler,
-      // which is attached to the window so its queue keeps draining, instead of the
-      // detached webView/old parent whose post() runnables may never run.
-      if (retriesLeft > 0) {
-        // postDelayed (not a tight container.post spin): a small delay lets the
-        // old parent's pending layout / removeView flush between attempts, instead
-        // of re-checking on the very next vsync before anything could change.
-        container.postDelayed({
-          attachToContainer(container, generation, retriesLeft = retriesLeft - 1)
-        }, attachRetryDelayMs)
+    if (currentParent != null) {
+      if (canRetry) {
+        webView.post { attachToContainer(container, generation, canRetry = false) }
       } else {
-        // Last resort before giving up: the old parent never released the WebView
-        // through the normal path. Force-detach it and try the attach once more so
-        // we don't leave the WebView unparented (the blank-chart symptom).
-        (currentParent as? ViewGroup)?.let { forceDetach(it) }
-        if (webView.parent == null || webView.parent === container) {
-          attachToContainer(container, generation, retriesLeft = 0)
-        } else {
-          android.util.Log.w(
-            TAG,
-            "Skip attach key=$key after retries because WebView parent was not cleared: $currentParent",
-          )
-        }
+        android.util.Log.w(
+          "ChartWebviewPool",
+          "Skip attach key=$key because WebView parent was not cleared: $currentParent",
+        )
       }
       return
     }
@@ -399,27 +260,6 @@ class PooledChartWebView private constructor(
     refreshSnapshotSoon()
   }
 
-  /**
-   * Remove the WebView from [container] ONLY if it is still parented there.
-   *
-   * Called on a pooled host's final teardown (dispose): that host's container is
-   * about to be dropped from the view tree, and a pooled host deliberately does
-   * NOT detach on the YIELD path (to avoid racing a rapid re-claim). Without this,
-   * the shared WebView stays parented to the dropped/detached container; the next
-   * host's [attachTo] then keeps hitting "old parent not cleared" (removeView on a
-   * detached container isn't applied synchronously) and retries forever — leaving
-   * the new chart slot blank/white. The `parent === container` guard makes this
-   * safe against ordering: if a new host has already re-claimed and reparented the
-   * WebView, we must NOT rip it back off, so we only remove when WE still hold it.
-   */
-  fun detachFrom(container: ViewGroup) {
-    runOnUiThread {
-      if (webView.parent === container) {
-        forceDetach(container)
-      }
-    }
-  }
-
   /** Remove the WebView from its current parent (keeps it alive, warm). */
   fun detachFromParent() {
     runOnUiThread {
@@ -549,26 +389,13 @@ class PooledChartWebView private constructor(
    * so reparenting / redundant prop re-applies never reload (which would lose
    * chart state, the whole point of pooling).
    */
-  fun setSource(
-    uri: String?,
-    localBundle: String?,
-    entry: String?,
-    paramsJson: String?,
-    assetHost: String?,
-  ) {
+  fun setSource(uri: String?, localBundle: String?, entry: String?, paramsJson: String?) {
     // Never load before the document-start bridge is registered — otherwise the
     // page boots without the bridge and its first $private requests are lost. The
     // host re-calls setSource once the bridgeScript prop arrives.
     if (!bridgeRegistered) return
-    // Per-instance asset host: fall back to the built-in appassets host (old
-    // behavior) when the app doesn't pass one. Empty string is treated as absent.
-    // Sanitize untrusted values before they reach the privileged-bridge origin
-    // ("https://$assetHost") and WebViewAssetLoader.setDomain — see sanitizeAssetHost.
-    this.assetHost = assetHost?.takeIf { it.isNotEmpty() }
-      ?.let { sanitizeAssetHost(it) } ?: ASSET_HOST
-    if (localBundle != lastLocalBundle || this.assetHost != lastAssetHost) {
+    if (localBundle != lastLocalBundle) {
       lastLocalBundle = localBundle
-      lastAssetHost = this.assetHost
       rebuildAssetLoader(localBundle)
     }
     // Register the document-start bridge scoped to exactly the origin(s) this load
@@ -610,36 +437,7 @@ class PooledChartWebView private constructor(
       (webView.parent as? ViewGroup)?.removeView(webView)
       webView.destroy()
       val n = liveCount.decrementAndGet()
-      android.util.Log.d(TAG, "WebView DESTROYED key=$key liveCount=$n")
-    }
-  }
-
-  // Validate an incoming assetHost prop before it becomes the trusted bridge
-  // origin ("https://$assetHost") and WebViewAssetLoader.setDomain(assetHost). A
-  // malformed value (scheme, path, '/', '@'/userinfo, whitespace, port, query)
-  // could corrupt the privileged-origin allowlist or throw on the UI thread, so a
-  // candidate that is not a bare hostname falls back to the built-in ASSET_HOST.
-  private fun sanitizeAssetHost(candidate: String): String {
-    val invalid = {
-      android.util.Log.w(
-        TAG,
-        "Ignoring invalid assetHost '$candidate'; falling back to default $ASSET_HOST",
-      )
-      ASSET_HOST
-    }
-    // Cheap rejects first: a bare hostname has no whitespace and no '/'.
-    if (candidate.any { it.isWhitespace() } || candidate.contains('/')) return invalid()
-    return try {
-      val uri = java.net.URI("https://$candidate")
-      val bareHost =
-        uri.host == candidate &&
-        uri.path.isNullOrEmpty() &&
-        uri.userInfo == null &&
-        uri.query == null &&
-        uri.port == -1
-      if (bareHost) candidate else invalid()
-    } catch (e: Exception) {
-      invalid()
+      android.util.Log.d("ChartWebviewPool", "WebView DESTROYED key=$key liveCount=$n")
     }
   }
 
@@ -648,28 +446,9 @@ class PooledChartWebView private constructor(
       assetLoader = null
       return
     }
-    // Narrow the path handler to ONLY the offline bundle subtree
-    // (/<localBundle>/, e.g. /tradingview-assets/) instead of intercepting all of
-    // "/". When the bundle is served under the real chart origin (`assetHost`),
-    // intercepting "/" would shadow every web path on that domain; with the narrow
-    // handler, unmatched paths fall through to the network — so an `assetHost`
-    // that is a real public domain keeps behaving normally off-bundle.
-    // computeTargetUrl produces https://<assetHost>/<localBundle>/<entry>, which
-    // stays inside this handler's path. (Path built as /<localBundle>/ so a
-    // localBundle that already has a trailing slash doesn't double it.)
-    val bundleDir = localBundle.trim('/')
-    val bundlePath = "/$bundleDir/"
-    // WebViewAssetLoader strips the registered prefix before calling the handler,
-    // so AssetsPathHandler alone would resolve the remainder against the assets
-    // ROOT (assets/<entry>) and lose the bundle namespace. Re-prepend <bundleDir>/
-    // so we still serve from assets/<localBundle>/<entry>. Returning null on a
-    // miss lets WebViewAssetLoader fall through to the network.
-    val assets = WebViewAssetLoader.AssetsPathHandler(webView.context)
-    val namespacedHandler =
-      WebViewAssetLoader.PathHandler { suffix -> assets.handle("$bundleDir/$suffix") }
     assetLoader = WebViewAssetLoader.Builder()
-      .setDomain(assetHost)
-      .addPathHandler(bundlePath, namespacedHandler)
+      .setDomain(ASSET_HOST)
+      .addPathHandler("/", WebViewAssetLoader.AssetsPathHandler(webView.context))
       .build()
   }
 
@@ -683,21 +462,15 @@ class PooledChartWebView private constructor(
     if (localBundle.isNullOrEmpty()) return null
     val entryPath = entry?.takeIf { it.isNotEmpty() } ?: DEFAULT_ENTRY
     val query = buildQueryFromParamsJson(paramsJson)
-    // Normalize the bundle dir the SAME way rebuildAssetLoader does (trim '/'), so
-    // the URL has exactly single slashes between host, bundle dir and entry. A raw
-    // localBundle like "/tradingview-assets/" would otherwise yield
-    // https://host//tradingview-assets//index.html, which misses the registered
-    // handler prefix → falls through to the network → blank chart.
-    val bundleDir = localBundle.trim('/')
     return buildString {
       append("https://")
-      append(assetHost)
+      append(ASSET_HOST)
       append('/')
       // Serve the offline bundle from assets/<localBundle>/ (namespaced) rather
       // than the assets root, so it doesn't collide with other bundled assets
       // (e.g. web-embed). The dist uses relative asset paths (PUBLIC_URL='./'),
       // so loading the entry from a subpath resolves the rest correctly.
-      append(bundleDir)
+      append(localBundle)
       append('/')
       append(entryPath)
       if (query.isNotEmpty()) {