@onekeyfe/react-native-chart-webview 3.0.55 → 3.0.57

package/ChartWebview.podspec

@@ -21,6 +21,9 @@ 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,34 +98,46 @@ 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; applySourceIfOwner() }
+    set(value) { _uri = value; applySource() }
 
   private var _localBundle: String? = null
   override var localBundle: String?
     get() = _localBundle
-    set(value) { _localBundle = value; applySourceIfOwner() }
+    set(value) { _localBundle = value; applySource() }
 
   private var _entry: String? = null
   override var entry: String?
     get() = _entry
-    set(value) { _entry = value; applySourceIfOwner() }
+    set(value) { _entry = value; applySource() }
 
   private var _paramsJson: String? = null
   override var paramsJson: String?
     get() = _paramsJson
-    set(value) { _paramsJson = value; applySourceIfOwner() }
+    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() }
 
   // 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
-    // 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() }
+    set(value) { _bridgeScript = value; applySource() }
 
   // --- Singleton props ---
   // `pooled` + non-empty `reuseKey` => the backing WebView is shared (keyed by
@@ -162,6 +174,22 @@ 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
@@ -219,6 +247,9 @@ 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) {
@@ -226,13 +257,24 @@ 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
-      // 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 ?: "")
+      // PERF: a host is now showing the chart — make sure the renderer is running.
+      entry.resume()
       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.
@@ -248,6 +290,11 @@ 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()
     }
   }
 
@@ -257,19 +304,30 @@ 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)
+    pooled.setSource(_uri, _localBundle, _entry, _paramsJson, _assetHost)
   }
 
-  private fun applySourceIfOwner() {
+  // 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() {
     val pooled = backing ?: return
-    if (pooled.owner == this) {
-      // Register the bridge before any load setSource may trigger (setSource
-      // defers loading until the bridge is registered).
+    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) {
       pooled.setBridgeScript(_bridgeScript ?: "")
-      pooled.setSource(_uri, _localBundle, _entry, _paramsJson)
+      pooled.setSource(_uri, _localBundle, _entry, _paramsJson, _assetHost)
     }
   }
 
@@ -359,7 +417,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.
-  fun dispose() {
+  override fun dispose() {
     stopOwnCapture()
     container.removeCallbacks(reconcileRunnable)
     container.removeCallbacks(revealFallbackRunnable)
@@ -368,10 +426,19 @@ 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

@@ -52,6 +52,9 @@ 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
@@ -123,12 +126,12 @@ class PooledChartWebView private constructor(
   }
 
   // The trusted origin set for the current source: the offline asset origin
-  // (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.
+  // (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.
   private fun trustedOriginsFor(uri: String?): Set<String> {
-    val origins = linkedSetOf("https://$ASSET_HOST")
+    val origins = linkedSetOf("https://$assetHost")
     originOf(uri)?.let { origins.add(it) }
     return origins
   }
@@ -148,11 +151,74 @@ class PooledChartWebView private constructor(
   }
 
   /** The host currently displaying this WebView; page events route here. */
-  var owner: HybridChartWebview? = null
+  private var _owner: HybridChartWebview? = null
+  var owner: HybridChartWebview?
+    get() = _owner
+    set(value) {
+      _owner = value
+    }
+  // 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.
+  private var _warmDriver: HybridChartWebview? = null
+  var warmDriver: HybridChartWebview?
+    get() = _warmDriver
+    set(value) {
+      _warmDriver = value
+    }
+
+  // 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.i(TAG, "pool[$key] PAUSE (renderer idle)")
+    runOnUiThread { webView.onPause() }
+  }
+
+  fun resume() {
+    if (!paused) return
+    paused = false
+    android.util.Log.i(TAG, "pool[$key] RESUME")
+    runOnUiThread {
+      webView.onResume()
+      webView.invalidate()
+    }
+  }
 
   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
@@ -179,9 +245,28 @@ 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("ChartWebviewPool", "WebView CREATED key=$key liveCount=$n")
+    android.util.Log.d(TAG, "WebView CREATED key=$key liveCount=$n")
 
     webView.webViewClient = object : WebViewClientCompat() {
       override fun shouldInterceptRequest(
@@ -191,11 +276,12 @@ 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?.dispatchLoadEnd()
+        (owner ?: warmDriver)?.dispatchLoadEnd()
         // Prime the snapshot so the first move already has a frame to mask with.
         refreshSnapshotSoon()
       }
@@ -217,7 +303,26 @@ class PooledChartWebView private constructor(
   private inner class ChartBridge {
     @JavascriptInterface
     fun postMessage(message: String) {
-      runOnUiThread { owner?.dispatchMessage(message) }
+      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) {}
+    parent.removeView(webView)
+    if (webView.parent === parent) {
+      try { parent.removeViewInLayout(webView) } catch (e: Throwable) {}
+      parent.requestLayout()
     }
   }
 
@@ -225,23 +330,30 @@ class PooledChartWebView private constructor(
   fun attachTo(container: ViewGroup) {
     val generation = attachGeneration.incrementAndGet()
     runOnUiThread {
-      attachToContainer(container, generation, canRetry = true)
+      attachToContainer(container, generation, retriesLeft = 12)
     }
   }
 
-  private fun attachToContainer(container: ViewGroup, generation: Int, canRetry: Boolean) {
+  private fun attachToContainer(container: ViewGroup, generation: Int, retriesLeft: Int) {
     if (generation != attachGeneration.get()) return
     if (webView.parent === container) return
 
-    (webView.parent as? ViewGroup)?.removeView(webView)
+    (webView.parent as? ViewGroup)?.let { forceDetach(it) }
     val currentParent = webView.parent
-    if (currentParent != null) {
-      if (canRetry) {
-        webView.post { attachToContainer(container, generation, canRetry = false) }
+    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) {
+        container.post {
+          attachToContainer(container, generation, retriesLeft = retriesLeft - 1)
+        }
       } else {
         android.util.Log.w(
-          "ChartWebviewPool",
-          "Skip attach key=$key because WebView parent was not cleared: $currentParent",
+          TAG,
+          "Skip attach key=$key after retries because WebView parent was not cleared: $currentParent",
         )
       }
       return
@@ -260,6 +372,27 @@ 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 {
@@ -389,13 +522,23 @@ 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?) {
+  fun setSource(
+    uri: String?,
+    localBundle: String?,
+    entry: String?,
+    paramsJson: String?,
+    assetHost: 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
-    if (localBundle != lastLocalBundle) {
+    // 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.
+    this.assetHost = assetHost?.takeIf { it.isNotEmpty() } ?: ASSET_HOST
+    if (localBundle != lastLocalBundle || this.assetHost != lastAssetHost) {
       lastLocalBundle = localBundle
+      lastAssetHost = this.assetHost
       rebuildAssetLoader(localBundle)
     }
     // Register the document-start bridge scoped to exactly the origin(s) this load
@@ -437,7 +580,7 @@ class PooledChartWebView private constructor(
       (webView.parent as? ViewGroup)?.removeView(webView)
       webView.destroy()
       val n = liveCount.decrementAndGet()
-      android.util.Log.d("ChartWebviewPool", "WebView DESTROYED key=$key liveCount=$n")
+      android.util.Log.d(TAG, "WebView DESTROYED key=$key liveCount=$n")
     }
   }
 
@@ -446,9 +589,28 @@ 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(ASSET_HOST)
-      .addPathHandler("/", WebViewAssetLoader.AssetsPathHandler(webView.context))
+      .setDomain(assetHost)
+      .addPathHandler(bundlePath, namespacedHandler)
       .build()
   }
 
@@ -464,7 +626,7 @@ class PooledChartWebView private constructor(
     val query = buildQueryFromParamsJson(paramsJson)
     return buildString {
       append("https://")
-      append(ASSET_HOST)
+      append(assetHost)
       append('/')
       // Serve the offline bundle from assets/<localBundle>/ (namespaced) rather
       // than the assets root, so it doesn't collide with other bundled assets