@capgo/inappbrowser 8.1.26 → 8.3.0-alpha.0

package/README.md

@@ -1,9 +1,22 @@
 # @capgo/inappbrowser
- <a href="https://capgo.app/"><img src='https://raw.githubusercontent.com/Cap-go/capgo/main/assets/capgo_banner.png' alt='Capgo - Instant updates for capacitor'/></a>
+
+<a href="https://capgo.app/">
+  <img
+    src="https://raw.githubusercontent.com/Cap-go/capgo/main/assets/capgo_banner.png"
+    alt="Capgo - Instant updates for capacitor"
+  />
+</a>
 
 <div align="center">
-  <h2><a href="https://capgo.app/?ref=plugin_inappbrowser"> ➡️ Get Instant updates for your App with Capgo</a></h2>
-  <h2><a href="https://capgo.app/consulting/?ref=plugin_inappbrowser"> Missing a feature? We’ll build the plugin for you 💪</a></h2>
+  <h2>
+    <a href="https://capgo.app/?ref=plugin_inappbrowser"> ➡️ Get Instant updates for your App with Capgo</a>
+  </h2>
+  <h2>
+    <a href="https://capgo.app/consulting/?ref=plugin_inappbrowser">
+      {' '}
+      Missing a feature? We’ll build the plugin for you 💪
+    </a>
+  </h2>
 </div>
 
 Capacitor plugin in app browser with urlChangeEvent, two way communication, camera and microphone usage, etc.
@@ -30,10 +43,10 @@ The most complete doc is available here: https://capgo.app/docs/plugins/inappbro
 
 | Plugin version | Capacitor compatibility | Maintained |
 | -------------- | ----------------------- | ---------- |
-| v8.\*.\*       | v8.\*.\*                | ✅          |
-| v7.\*.\*       | v7.\*.\*                | On demand   |
-| v6.\*.\*       | v6.\*.\*                | ❌          |
-| v5.\*.\*       | v5.\*.\*                | ❌          |
+| v8.\*.\*       | v8.\*.\*                | ✅         |
+| v7.\*.\*       | v7.\*.\*                | On demand  |
+| v6.\*.\*       | v6.\*.\*                | ❌         |
+| v5.\*.\*       | v5.\*.\*                | ❌         |
 
 > **Note:** The major version of this plugin follows the major version of Capacitor. Use the version that matches your Capacitor installation (e.g., plugin v8 for Capacitor 8). Only the latest major version is actively maintained.
 
@@ -43,28 +56,50 @@ The most complete doc is available here: https://capgo.app/docs/plugins/inappbro
 npm install @capgo/inappbrowser
 npx cap sync
 ```
+
 ## Usage
 
+```js
+import { InAppBrowser } from '@capgo/inappbrowser';
+
+InAppBrowser.open({ url: 'YOUR_URL' });
+```
+
+### Customize Chrome Custom Tab Appearance (Android)
+
+The `open()` method launches a Chrome Custom Tab on Android. You can customize its appearance to blend with your app:
+
 ```js
 import { InAppBrowser } from '@capgo/inappbrowser'
 
-InAppBrowser.open({ url: "YOUR_URL" });
+InAppBrowser.open({
+  url: "https://example.com",
+  toolbarColor: "#1A1A2E",      // Match your app's theme
+  showTitle: true,               // Show page title instead of raw URL
+  showArrow: true,               // Back arrow instead of X close icon
+  urlBarHidingEnabled: true,     // Auto-hide URL bar on scroll
+  disableShare: true,            // Remove share from overflow menu
+  disableBookmark: true,         // Hide bookmark icon (undocumented, may break)
+  disableDownload: true,         // Hide download icon (undocumented, may break)
+});
 ```
 
+All CCT options are Android-only and safely ignored on iOS. See [`OpenOptions`](#openoptions) for full documentation.
+
 ### Open WebView with Custom Dimensions
 
 By default, the webview opens in fullscreen. You can set custom dimensions to control the size and position:
 
 ```js
-import { InAppBrowser } from '@capgo/inappbrowser'
+import { InAppBrowser } from '@capgo/inappbrowser';
 
 // Open with custom dimensions (400x600 at position 50,100)
 const { id } = await InAppBrowser.openWebView({
-  url: "YOUR_URL",
+  url: 'YOUR_URL',
   width: 400,
   height: 600,
   x: 50,
-  y: 100
+  y: 100,
 });
 
 // Update dimensions at runtime
@@ -73,7 +108,7 @@ InAppBrowser.updateDimensions({
   width: 500,
   height: 700,
   x: 100,
-  y: 150
+  y: 150,
 });
 ```
 
@@ -84,11 +119,11 @@ InAppBrowser.updateDimensions({
 To create a webView with a 20px bottom margin (safe margin area outside the browser):
 
 ```js
-import { InAppBrowser } from '@capgo/inappbrowser'
+import { InAppBrowser } from '@capgo/inappbrowser';
 
 InAppBrowser.openWebView({
-  url: "YOUR_URL",
-  enabledSafeBottomMargin: true
+  url: 'YOUR_URL',
+  enabledSafeBottomMargin: true,
 });
 ```
 
@@ -99,15 +134,16 @@ Web platform is not supported. Use `window.open` instead.
 To open the webview in true full screen mode (content extends behind the status bar), set `enabledSafeTopMargin` to `false`:
 
 ```js
-import { InAppBrowser } from '@capgo/inappbrowser'
+import { InAppBrowser } from '@capgo/inappbrowser';
 
 InAppBrowser.openWebView({
-  url: "YOUR_URL",
-  enabledSafeTopMargin: false  // Disables safe area at top, allows full screen
+  url: 'YOUR_URL',
+  enabledSafeTopMargin: false, // Disables safe area at top, allows full screen
 });
 ```
 
 This option works independently of the toolbar type:
+
 - **iOS**: The webview extends behind the status bar, providing true edge-to-edge content
 - **Android**: The top margin is disabled, allowing content to fill the entire screen
 
@@ -193,16 +229,16 @@ With this plugin you can send events from the main app to the inappbrowser and v
 #### Main app to inappbrowser, detail object is mendatory
 
 ```js
-const { id } = await InAppBrowser.openWebView({ url: "YOUR_URL" });
-InAppBrowser.postMessage({ id, detail: { message: "myMessage" } });
+const { id } = await InAppBrowser.openWebView({ url: 'YOUR_URL' });
+InAppBrowser.postMessage({ id, detail: { message: 'myMessage' } });
 // Or broadcast to all open webviews
-InAppBrowser.postMessage({ detail: { message: "broadcast" } });
+InAppBrowser.postMessage({ detail: { message: 'broadcast' } });
 ```
 
 #### Receive event from native in the inappbrowser
 
 ```js
-window.addEventListener("messageFromNative", (event) => {
+window.addEventListener('messageFromNative', (event) => {
   console.log(event);
 });
 ```
@@ -210,13 +246,13 @@ window.addEventListener("messageFromNative", (event) => {
 #### Send event from inappbrowser to main app, detail object is mendatory
 
 ```js
-window.mobileApp.postMessage({ detail: { message: "myMessage" } });
+window.mobileApp.postMessage({ detail: { message: 'myMessage' } });
 ```
 
 #### Receive event from inappbrowser in the main app
 
 ```js
-InAppBrowser.addListener("messageFromWebview", (event) => {
+InAppBrowser.addListener('messageFromWebview', (event) => {
   console.log(event.id, event.detail);
 });
 ```
@@ -251,6 +287,8 @@ window.mobileApp.close();
 * [`addListener('messageFromWebview', ...)`](#addlistenermessagefromwebview-)
 * [`addListener('browserPageLoaded', ...)`](#addlistenerbrowserpageloaded-)
 * [`addListener('pageLoadError', ...)`](#addlistenerpageloaderror-)
+* [`addListener('proxyRequest', ...)`](#addlistenerproxyrequest-)
+* [`handleProxyRequest(...)`](#handleproxyrequest)
 * [`removeAllListeners()`](#removealllisteners)
 * [`reload(...)`](#reload)
 * [`updateDimensions(...)`](#updatedimensions)
@@ -635,6 +673,45 @@ Will be triggered when page load error
 --------------------
 
 
+### addListener('proxyRequest', ...)
+
+```typescript
+addListener(eventName: 'proxyRequest', listenerFunc: (event: ProxyRequest) => void) => Promise<PluginListenerHandle>
+```
+
+Listen for proxied requests from the in-app browser webview.
+Use addProxyHandler() wrapper instead of calling this directly.
+
+| Param              | Type                                                                      |
+| ------------------ | ------------------------------------------------------------------------- |
+| **`eventName`**    | <code>'proxyRequest'</code>                                               |
+| **`listenerFunc`** | <code>(event: <a href="#proxyrequest">ProxyRequest</a>) =&gt; void</code> |
+
+**Returns:** <code>Promise&lt;<a href="#pluginlistenerhandle">PluginListenerHandle</a>&gt;</code>
+
+**Since:** 9.0.0
+
+--------------------
+
+
+### handleProxyRequest(...)
+
+```typescript
+handleProxyRequest(options: { requestId: string; response: ProxyResponse | null; webviewId?: string; }) => Promise<void>
+```
+
+Internal method: sends a proxied response back to native.
+Called by addProxyHandler() wrapper — not intended for direct use.
+
+| Param         | Type                                                                                                                  |
+| ------------- | --------------------------------------------------------------------------------------------------------------------- |
+| **`options`** | <code>{ requestId: string; response: <a href="#proxyresponse">ProxyResponse</a> \| null; webviewId?: string; }</code> |
+
+**Since:** 9.0.0
+
+--------------------
+
+
 ### removeAllListeners()
 
 ```typescript
@@ -746,11 +823,18 @@ And in the AndroidManifest.xml file:
 
 #### OpenOptions
 
-| Prop                         | Type                 | Description                                                                                                           | Since |
-| ---------------------------- | -------------------- | --------------------------------------------------------------------------------------------------------------------- | ----- |
-| **`url`**                    | <code>string</code>  | Target URL to load.                                                                                                   | 0.1.0 |
-| **`isPresentAfterPageLoad`** | <code>boolean</code> | if true, the browser will be presented after the page is loaded, if false, the browser will be presented immediately. | 0.1.0 |
-| **`preventDeeplink`**        | <code>boolean</code> | if true the deeplink will not be opened, if false the deeplink will be opened when clicked on the link                | 0.1.0 |
+| Prop                         | Type                 | Description                                                                                                                                                                             | Default            | Since |
+| ---------------------------- | -------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------ | ----- |
+| **`url`**                    | <code>string</code>  | Target URL to load.                                                                                                                                                                     |                    | 0.1.0 |
+| **`isPresentAfterPageLoad`** | <code>boolean</code> | if true, the browser will be presented after the page is loaded, if false, the browser will be presented immediately.                                                                   |                    | 0.1.0 |
+| **`preventDeeplink`**        | <code>boolean</code> | if true the deeplink will not be opened, if false the deeplink will be opened when clicked on the link                                                                                  |                    | 0.1.0 |
+| **`toolbarColor`**           | <code>string</code>  | Toolbar background color in hex format (e.g., "#1A1A2E"). Applied to both light and dark color schemes. Also sets the navigation bar color to match. **Android only** — ignored on iOS. |                    | 8.2.0 |
+| **`urlBarHidingEnabled`**    | <code>boolean</code> | Whether the URL bar should auto-hide when the user scrolls down. The bar reappears on any upward scroll. **Android only** — ignored on iOS.                                             | <code>false</code> | 8.2.0 |
+| **`showTitle`**              | <code>boolean</code> | Show the page's HTML &lt;title&gt; in the toolbar instead of the raw URL. The true URL is still visible when the user taps the title area. **Android only** — ignored on iOS.           | <code>false</code> | 8.2.0 |
+| **`showArrow`**              | <code>boolean</code> | Replace the default "X" close icon with a back arrow. Makes the Custom Tab feel like a native navigation push rather than a modal overlay. **Android only** — ignored on iOS.           | <code>false</code> | 8.2.0 |
+| **`disableShare`**           | <code>boolean</code> | Remove the share action from the overflow menu. **Android only** — ignored on iOS.                                                                                                      | <code>false</code> | 8.2.0 |
+| **`disableBookmark`**        | <code>boolean</code> | Hide the bookmark star icon in the overflow menu. Uses an undocumented Chromium intent extra — may stop working on future Chrome updates. **Android only** — ignored on iOS.            | <code>false</code> | 8.2.0 |
+| **`disableDownload`**        | <code>boolean</code> | Hide the download icon in the overflow menu. Uses an undocumented Chromium intent extra — may stop working on future Chrome updates. **Android only** — ignored on iOS.                 | <code>false</code> | 8.2.0 |
 
 
 #### ClearCookieOptions
@@ -820,7 +904,7 @@ And in the AndroidManifest.xml file:
 | **`ignoreUntrustedSSLError`**          | <code>boolean</code>                                                                                                                                                   | ignoreUntrustedSSLError: if true, the webview will ignore untrusted SSL errors allowing the user to view the website.                                                                                                                                                                                                                                                                                                                                                                                                                                      | <code>false</code>                                            | 6.1.0  |
 | **`preShowScript`**                    | <code>string</code>                                                                                                                                                    | preShowScript: if isPresentAfterPageLoad is true and this variable is set the plugin will inject a script before showing the browser. This script will be run in an async context. The plugin will wait for the script to finish (max 10 seconds)                                                                                                                                                                                                                                                                                                          |                                                               | 6.6.0  |
 | **`preShowScriptInjectionTime`**       | <code>'documentStart' \| 'pageLoad'</code>                                                                                                                             | preShowScriptInjectionTime: controls when the preShowScript is injected. - "documentStart": injects before any page JavaScript runs (good for polyfills like Firebase) - "pageLoad": injects after page load (default, original behavior)                                                                                                                                                                                                                                                                                                                  | <code>"pageLoad"</code>                                       | 7.26.0 |
-| **`proxyRequests`**                    | <code>string</code>                                                                                                                                                    | proxyRequests is a regex expression. Please see [this pr](https://github.com/Cap-go/capacitor-inappbrowser/pull/222) for more info. (Android only)                                                                                                                                                                                                                                                                                                                                                                                                         |                                                               | 6.9.0  |
+| **`proxyRequests`**                    | <code>boolean</code>                                                                                                                                                   | When true, all HTTP/HTTPS requests from the webview are sent to the proxy handler registered via addProxyHandler(). The handler can return a custom Response or null for pass-through.                                                                                                                                                                                                                                                                                                                                                                     |                                                               | 9.0.0  |
 | **`buttonNearDone`**                   | <code>{ ios: { iconType: 'sf-symbol' \| 'asset'; icon: string; }; android: { iconType: 'asset' \| 'vector'; icon: string; width?: number; height?: number; }; }</code> | buttonNearDone allows for a creation of a custom button near the done/close button. The button is only shown when toolbarType is not "activity", "navigation", or "blank". For Android: - iconType must be "asset" - icon path should be in the public folder (e.g. "monkey.svg") - width and height are optional, defaults to 48dp - button is positioned at the end of toolbar with 8dp margin For iOS: - iconType can be "sf-symbol" or "asset" - for sf-symbol, icon should be the symbol name - for asset, icon should be the asset name              |                                                               | 6.7.0  |
 | **`textZoom`**                         | <code>number</code>                                                                                                                                                    | textZoom: sets the text zoom of the page in percent. Allows users to increase or decrease the text size for better readability.                                                                                                                                                                                                                                                                                                                                                                                                                            | <code>100</code>                                              | 7.6.0  |
 | **`preventDeeplink`**                  | <code>boolean</code>                                                                                                                                                   | preventDeeplink: if true, the deeplink will not be opened, if false the deeplink will be opened when clicked on the link. on IOS each schema need to be added to info.plist file under LSApplicationQueriesSchemes when false to make it work.                                                                                                                                                                                                                                                                                                             | <code>false</code>                                            | 0.1.0  |
@@ -883,6 +967,31 @@ And in the AndroidManifest.xml file:
 | **`url`** | <code>string</code> | Emit when a button is clicked. | 0.0.1 |
 
 
+#### ProxyRequest
+
+Represents an intercepted HTTP request from the in-app browser webview.
+
+| Prop            | Type                                                            | Description                                                                                                                                                                                                                                                                                             |
+| --------------- | --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **`requestId`** | <code>string</code>                                             | Unique identifier for this request, used to match responses                                                                                                                                                                                                                                             |
+| **`url`**       | <code>string</code>                                             | The full URL being requested                                                                                                                                                                                                                                                                            |
+| **`method`**    | <code>string</code>                                             | HTTP method (GET, POST, PUT, DELETE, etc.)                                                                                                                                                                                                                                                              |
+| **`headers`**   | <code><a href="#record">Record</a>&lt;string, string&gt;</code> | Request headers as key-value pairs                                                                                                                                                                                                                                                                      |
+| **`body`**      | <code>string \| null</code>                                     | Base64-encoded request body, or null if no body. On Android, requests from HTML elements (img, script, link, iframe) are intercepted natively and do not have access to the request body — this field will be empty for those requests. Requests from fetch() and XMLHttpRequest include the full body. |
+| **`webviewId`** | <code>string</code>                                             | ID of the webview that made this request                                                                                                                                                                                                                                                                |
+
+
+#### ProxyResponse
+
+Response to send back for a proxied request.
+
+| Prop          | Type                                                            | Description                         |
+| ------------- | --------------------------------------------------------------- | ----------------------------------- |
+| **`body`**    | <code>string</code>                                             | Base64-encoded response body        |
+| **`status`**  | <code>number</code>                                             | HTTP status code                    |
+| **`headers`** | <code><a href="#record">Record</a>&lt;string, string&gt;</code> | Response headers as key-value pairs |
+
+
 #### DimensionOptions
 
 | Prop         | Type                | Description                             |
@@ -996,5 +1105,6 @@ Construct a type with a set of properties K of type T
 </docgen-api>
 
 **Credits**
- - [WKWebViewController](https://github.com/Meniny/WKWebViewController) - for iOS
- - [CapBrowser](https://github.com/gadapa-rakesh/CapBrowser) - For the base in capacitor v2
+
+- [WKWebViewController](https://github.com/Meniny/WKWebViewController) - for iOS
+- [CapBrowser](https://github.com/gadapa-rakesh/CapBrowser) - For the base in capacitor v2

package/android/src/main/assets/proxy-bridge.js

@@ -0,0 +1,197 @@
+"use strict";
+(() => {
+  var __async = (__this, __arguments, generator) => {
+    return new Promise((resolve, reject) => {
+      var fulfilled = (value) => {
+        try {
+          step(generator.next(value));
+        } catch (e) {
+          reject(e);
+        }
+      };
+      var rejected = (value) => {
+        try {
+          step(generator.throw(value));
+        } catch (e) {
+          reject(e);
+        }
+      };
+      var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+      step((generator = generator.apply(__this, __arguments)).next());
+    });
+  };
+
+  // src/proxy-bridge.ts
+  (function() {
+    const proxyBridge = window.__capgoProxy;
+    if (!proxyBridge) return;
+    const accessToken = "___CAPGO_PROXY_TOKEN___";
+    let requestCounter = 0;
+    function generateRequestId() {
+      return "pr_" + Date.now() + "_" + requestCounter++;
+    }
+    function arrayBufferToBase64(buffer) {
+      const bytes = new Uint8Array(buffer);
+      let binary = "";
+      for (let i = 0; i < bytes.byteLength; i++) {
+        binary += String.fromCharCode(bytes[i]);
+      }
+      return btoa(binary);
+    }
+    function stringToBase64(str) {
+      return btoa(unescape(encodeURIComponent(str)));
+    }
+    function resolveUrl(url) {
+      if (url && !url.match(/^[a-zA-Z][a-zA-Z0-9+\-.]*:\/\//)) {
+        try {
+          return new URL(url, window.location.href).href;
+        } catch (_e) {
+          return url;
+        }
+      }
+      return url;
+    }
+    function bodyToBase64(body) {
+      return __async(this, null, function* () {
+        if (body === null || body === void 0) return null;
+        if (typeof body === "string") return stringToBase64(body);
+        if (body instanceof ArrayBuffer) return arrayBufferToBase64(body);
+        if (ArrayBuffer.isView(body))
+          return arrayBufferToBase64(body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength));
+        if (body instanceof Blob) {
+          const ab = yield body.arrayBuffer();
+          return arrayBufferToBase64(ab);
+        }
+        if (body instanceof FormData) {
+          const ab = yield new Response(body).arrayBuffer();
+          return arrayBufferToBase64(ab);
+        }
+        if (body instanceof URLSearchParams) {
+          return stringToBase64(body.toString());
+        }
+        return null;
+      });
+    }
+    const originalFetch = window.fetch;
+    window.fetch = function(input, init) {
+      return __async(this, null, function* () {
+        const requestId = generateRequestId();
+        let url;
+        let method = "GET";
+        const headers = {};
+        let body = null;
+        if (input instanceof Request) {
+          url = input.url;
+          method = input.method;
+          input.headers.forEach((v, k) => {
+            headers[k] = v;
+          });
+          try {
+            const cloned = input.clone();
+            const ab = yield cloned.arrayBuffer();
+            if (ab.byteLength > 0) {
+              body = ab;
+            }
+          } catch (_e) {
+          }
+        } else {
+          url = input instanceof URL ? input.toString() : input;
+        }
+        url = resolveUrl(url);
+        if (init) {
+          if (init.method) method = init.method;
+          if (init.headers) {
+            const h = new Headers(init.headers);
+            h.forEach((v, k) => {
+              headers[k] = v;
+            });
+          }
+          if (init.body !== void 0) body = init.body;
+        }
+        if (body instanceof FormData) {
+          const encoded = new Response(body);
+          const ct = encoded.headers.get("content-type");
+          if (ct) {
+            Object.keys(headers).forEach((k) => {
+              if (k.toLowerCase() === "content-type") delete headers[k];
+            });
+            headers["content-type"] = ct;
+          }
+          body = yield encoded.arrayBuffer();
+        }
+        const base64Body = yield bodyToBase64(body);
+        proxyBridge.storeRequest(accessToken, requestId, method, JSON.stringify(headers), base64Body || "");
+        const proxyUrl = "/_capgo_proxy_?u=" + encodeURIComponent(url) + "&rid=" + requestId;
+        return originalFetch.call(window, proxyUrl, { method: "GET" });
+      });
+    };
+    const XHROpen = XMLHttpRequest.prototype.open;
+    const XHRSend = XMLHttpRequest.prototype.send;
+    const XHRSetHeader = XMLHttpRequest.prototype.setRequestHeader;
+    XMLHttpRequest.prototype.open = function(method, url, ...rest) {
+      this.__proxyMethod = method;
+      this.__proxyUrl = resolveUrl(url instanceof URL ? url.toString() : url);
+      this.__proxyHeaders = {};
+      return XHROpen.apply(this, [method, url, ...rest]);
+    };
+    XMLHttpRequest.prototype.setRequestHeader = function(name, value) {
+      if (this.__proxyHeaders) {
+        this.__proxyHeaders[name] = value;
+      }
+      return XHRSetHeader.call(this, name, value);
+    };
+    XMLHttpRequest.prototype.send = function(body) {
+      const xhr = this;
+      const requestId = generateRequestId();
+      const method = xhr.__proxyMethod || "GET";
+      const url = xhr.__proxyUrl || "";
+      const headers = xhr.__proxyHeaders || {};
+      function completeSend(base64Body) {
+        proxyBridge.storeRequest(accessToken, requestId, method, JSON.stringify(headers), base64Body);
+        const proxyUrl = "/_capgo_proxy_?u=" + encodeURIComponent(url) + "&rid=" + requestId;
+        XHROpen.call(xhr, "GET", proxyUrl, true);
+        XHRSend.call(xhr, null);
+      }
+      if (body === null || body === void 0) {
+        completeSend("");
+        return;
+      }
+      if (typeof body === "string") {
+        completeSend(stringToBase64(body));
+        return;
+      }
+      if (body instanceof ArrayBuffer) {
+        completeSend(arrayBufferToBase64(body));
+        return;
+      }
+      if (ArrayBuffer.isView(body)) {
+        completeSend(arrayBufferToBase64(body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength)));
+        return;
+      }
+      if (body instanceof URLSearchParams) {
+        completeSend(stringToBase64(body.toString()));
+        return;
+      }
+      if (body instanceof Blob || body instanceof FormData) {
+        const encoded = new Response(body);
+        if (body instanceof FormData) {
+          const ct = encoded.headers.get("content-type");
+          if (ct) {
+            Object.keys(headers).forEach((k) => {
+              if (k.toLowerCase() === "content-type") delete headers[k];
+            });
+            headers["content-type"] = ct;
+          }
+        }
+        encoded.arrayBuffer().then((ab) => {
+          completeSend(arrayBufferToBase64(ab));
+        }).catch((_e) => {
+          console.error("[proxy-bridge] Failed to encode Blob/FormData body:", _e);
+          completeSend("");
+        });
+        return;
+      }
+      completeSend("");
+    };
+  })();
+})();