@meshconnect/web-link-sdk 3.12.0 → 3.14.1

package/Link.js

@@ -49,6 +49,8 @@ import { addPopup, buildIframeAllowPolicy, iframeId, removePopup } from './utils
 import { isLinkEventTypeKey } from './utils/event-types';
 import { sdkSpecs } from './utils/sdk-specs';
 import { appendQueryParam } from './utils/url';
+import { JIT_REQUEST_MESSAGE_TYPE, SESSION_NONCE_PARAM } from './utils/backup';
+import { createBackupFlow } from './backupFlow';
 import { BridgeParent } from '@meshconnect/uwc-bridge-parent';
 import { createPrewarmIframe, removePrewarmIframe } from './utils/prewarm';
 var currentOptions;
@@ -66,85 +68,147 @@ function sendMessageToIframe(message) {
         console.warn("Mesh SDK: Failed to deliver ".concat(message.type, " message to the iframe - no iframe element found"));
         return;
     }
-    if (!linkTokenOrigin) {
+    // Tier 2 is a sandboxed, opaque-origin iframe (no pinnable origin) — post with a
+    // '*' target; the widget is our own bundled content and authenticates us in turn.
+    var target = backup.isTier2() ? '*' : linkTokenOrigin;
+    if (!target) {
         console.warn("Mesh SDK: Failed to deliver ".concat(message.type, " message to the iframe - no link token origin found"));
         return;
     }
     try {
-        (_a = iframe.contentWindow) === null || _a === void 0 ? void 0 : _a.postMessage(message, linkTokenOrigin);
+        (_a = iframe.contentWindow) === null || _a === void 0 ? void 0 : _a.postMessage(message, target);
     }
     catch (e) {
         console.error("Mesh SDK: Failed to deliver ".concat(message.type, " message to the iframe"));
         console.error(e);
     }
 }
+// The SDK-backup (deposit-only fallback) flow lives in its own module. It reads and
+// writes the shared Link state through this host bridge; the message handlers below
+// query it for backup state (`isTier2`/`getActiveFlow`/`isFromActiveWidget`) and
+// delegate the backup branches to it (`handleJitRequest`/`completeReadyHandshake`).
+var backupHost = {
+    getOptions: function () { return currentOptions; },
+    setOptions: function (options) {
+        currentOptions = options;
+    },
+    getLinkTokenOrigin: function () { return linkTokenOrigin; },
+    setLinkTokenOrigin: function (origin) {
+        linkTokenOrigin = origin;
+    },
+    setTargetOrigin: function (origin) {
+        targetOrigin = origin;
+    },
+    iframeElement: iframeElement,
+    setCurrentIframeId: function (id) {
+        currentIframeId = id;
+    },
+    getBridgeParent: function () { return bridgeParent; },
+    setBridgeParent: function (bridge) {
+        bridgeParent = bridge;
+    },
+    addMessageListener: function () { return window.addEventListener('message', eventsListener); },
+    removeMessageListener: function () {
+        return window.removeEventListener('message', eventsListener);
+    },
+    sendMessageToIframe: sendMessageToIframe
+};
+var backup = createBackupFlow(backupHost);
 function handleLinkEvent(event) {
     return __awaiter(this, void 0, void 0, function () {
-        var payload, payload, payload, payload;
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
-        return __generator(this, function (_l) {
-            switch (event.data.type) {
-                case 'brokerageAccountAccessToken': {
-                    payload = {
-                        accessToken: event.data.payload
-                    };
-                    (_a = currentOptions === null || currentOptions === void 0 ? void 0 : currentOptions.onEvent) === null || _a === void 0 ? void 0 : _a.call(currentOptions, {
-                        type: 'integrationConnected',
-                        payload: payload
-                    });
-                    (_b = currentOptions === null || currentOptions === void 0 ? void 0 : currentOptions.onIntegrationConnected) === null || _b === void 0 ? void 0 : _b.call(currentOptions, payload);
-                    break;
-                }
-                case 'delayedAuthentication': {
-                    payload = {
-                        delayedAuth: event.data.payload
-                    };
-                    (_c = currentOptions === null || currentOptions === void 0 ? void 0 : currentOptions.onEvent) === null || _c === void 0 ? void 0 : _c.call(currentOptions, {
-                        type: 'integrationConnected',
-                        payload: payload
-                    });
-                    (_d = currentOptions === null || currentOptions === void 0 ? void 0 : currentOptions.onIntegrationConnected) === null || _d === void 0 ? void 0 : _d.call(currentOptions, payload);
-                    break;
-                }
-                case 'transferFinished': {
-                    payload = event.data.payload;
-                    (_e = currentOptions === null || currentOptions === void 0 ? void 0 : currentOptions.onEvent) === null || _e === void 0 ? void 0 : _e.call(currentOptions, {
-                        type: 'transferCompleted',
-                        payload: payload
-                    });
-                    (_f = currentOptions === null || currentOptions === void 0 ? void 0 : currentOptions.onTransferFinished) === null || _f === void 0 ? void 0 : _f.call(currentOptions, payload);
-                    break;
-                }
-                case 'close':
-                case 'done': {
-                    payload = (_g = event.data) === null || _g === void 0 ? void 0 : _g.payload;
-                    (_h = currentOptions === null || currentOptions === void 0 ? void 0 : currentOptions.onExit) === null || _h === void 0 ? void 0 : _h.call(currentOptions, payload === null || payload === void 0 ? void 0 : payload.errorMessage, payload);
-                    bridgeParent === null || bridgeParent === void 0 ? void 0 : bridgeParent.destroy();
-                    removePopup();
-                    break;
-                }
-                case 'loaded': {
-                    sendMessageToIframe({
-                        type: 'meshSDKSpecs',
-                        payload: __assign({}, sdkSpecs)
-                    });
-                    if (currentOptions === null || currentOptions === void 0 ? void 0 : currentOptions.accessTokens) {
-                        sendMessageToIframe({
-                            type: 'frontAccessTokens',
-                            payload: currentOptions.accessTokens
-                        });
-                    }
-                    (_j = currentOptions === null || currentOptions === void 0 ? void 0 : currentOptions.onEvent) === null || _j === void 0 ? void 0 : _j.call(currentOptions, { type: 'pageLoaded' });
-                    break;
-                }
-                default: {
-                    if (isLinkEventTypeKey(event.data.type)) {
-                        (_k = currentOptions === null || currentOptions === void 0 ? void 0 : currentOptions.onEvent) === null || _k === void 0 ? void 0 : _k.call(currentOptions, event.data);
+        var payload, payload, payload, payload, onExit, linkEvent;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        return __generator(this, function (_k) {
+            switch (_k.label) {
+                case 0:
+                    if (!(event.data.type === JIT_REQUEST_MESSAGE_TYPE)) return [3 /*break*/, 2];
+                    return [4 /*yield*/, backup.handleJitRequest(event)];
+                case 1:
+                    _k.sent();
+                    return [2 /*return*/];
+                case 2:
+                    switch (event.data.type) {
+                        case 'brokerageAccountAccessToken': {
+                            payload = {
+                                accessToken: event.data.payload
+                            };
+                            (_a = currentOptions === null || currentOptions === void 0 ? void 0 : currentOptions.onEvent) === null || _a === void 0 ? void 0 : _a.call(currentOptions, {
+                                type: 'integrationConnected',
+                                payload: payload
+                            });
+                            (_b = currentOptions === null || currentOptions === void 0 ? void 0 : currentOptions.onIntegrationConnected) === null || _b === void 0 ? void 0 : _b.call(currentOptions, payload);
+                            break;
+                        }
+                        case 'delayedAuthentication': {
+                            payload = {
+                                delayedAuth: event.data.payload
+                            };
+                            (_c = currentOptions === null || currentOptions === void 0 ? void 0 : currentOptions.onEvent) === null || _c === void 0 ? void 0 : _c.call(currentOptions, {
+                                type: 'integrationConnected',
+                                payload: payload
+                            });
+                            (_d = currentOptions === null || currentOptions === void 0 ? void 0 : currentOptions.onIntegrationConnected) === null || _d === void 0 ? void 0 : _d.call(currentOptions, payload);
+                            break;
+                        }
+                        case 'transferFinished': {
+                            payload = event.data.payload;
+                            (_e = currentOptions === null || currentOptions === void 0 ? void 0 : currentOptions.onEvent) === null || _e === void 0 ? void 0 : _e.call(currentOptions, {
+                                type: 'transferCompleted',
+                                payload: payload
+                            });
+                            (_f = currentOptions === null || currentOptions === void 0 ? void 0 : currentOptions.onTransferFinished) === null || _f === void 0 ? void 0 : _f.call(currentOptions, payload);
+                            break;
+                        }
+                        case 'close':
+                        case 'done': {
+                            payload = (_g = event.data) === null || _g === void 0 ? void 0 : _g.payload;
+                            onExit = currentOptions === null || currentOptions === void 0 ? void 0 : currentOptions.onExit;
+                            window.removeEventListener('message', eventsListener);
+                            bridgeParent === null || bridgeParent === void 0 ? void 0 : bridgeParent.destroy();
+                            removePopup();
+                            backup.reset();
+                            onExit === null || onExit === void 0 ? void 0 : onExit(payload === null || payload === void 0 ? void 0 : payload.errorMessage, payload);
+                            break;
+                        }
+                        case 'loaded': {
+                            sendMessageToIframe({
+                                type: 'meshSDKSpecs',
+                                payload: __assign({}, sdkSpecs)
+                            });
+                            // Never forward integration access tokens to the backup widget: it is a
+                            // deposit-only flow served from an independent origin (no shared failure
+                            // domain with Mesh) and has no use for them — forwarding would leak the
+                            // user's credentials cross-origin. Gate on the POSITIVE `activeFlow ===
+                            // 'primary'` (not `!backupSession`): after an aborted re-open the stale
+                            // backup iframe can still fire `loaded` with the session cleared, and only
+                            // this positive check withholds the tokens in that dead window.
+                            if ((currentOptions === null || currentOptions === void 0 ? void 0 : currentOptions.accessTokens) &&
+                                backup.getActiveFlow() === 'primary') {
+                                sendMessageToIframe({
+                                    type: 'frontAccessTokens',
+                                    payload: currentOptions.accessTokens
+                                });
+                            }
+                            // The backup flow completes its ready handshake + config delivery here, but
+                            // only for a `loaded` from its own widget window (no-op otherwise).
+                            backup.completeReadyHandshake(event);
+                            (_h = currentOptions === null || currentOptions === void 0 ? void 0 : currentOptions.onEvent) === null || _h === void 0 ? void 0 : _h.call(currentOptions, { type: 'pageLoaded' });
+                            break;
+                        }
+                        default: {
+                            // `backupTierChanged` is generated by the SDK itself (backupFlow) — never
+                            // accept it from a widget, which could otherwise forge tier transitions.
+                            if (isLinkEventTypeKey(event.data.type) &&
+                                event.data.type !== 'backupTierChanged') {
+                                linkEvent = __assign({}, event.data);
+                                delete linkEvent[SESSION_NONCE_PARAM];
+                                (_j = currentOptions === null || currentOptions === void 0 ? void 0 : currentOptions.onEvent) === null || _j === void 0 ? void 0 : _j.call(currentOptions, linkEvent);
+                            }
+                            break;
+                        }
                     }
-                    break;
-                }
+                    return [2 /*return*/];
             }
-            return [2 /*return*/];
         });
     });
 }
@@ -153,14 +217,48 @@ function eventsListener(event) {
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    if (!(event.origin !== targetOrigin && event.origin !== linkTokenOrigin)) return [3 /*break*/, 1];
-                    console.warn('Received message from untrusted origin:', event.origin);
+                    if (!backup.isTier2()) return [3 /*break*/, 4];
+                    if (!(backup.isFromActiveWidget(event) && event.origin === 'null')) return [3 /*break*/, 2];
+                    return [4 /*yield*/, handleLinkEvent(event)];
+                case 1:
+                    _a.sent();
                     return [3 /*break*/, 3];
-                case 1: return [4 /*yield*/, handleLinkEvent(event)];
                 case 2:
-                    _a.sent();
+                    console.warn('Ignored backup Tier-2 message from an unexpected source');
                     _a.label = 3;
                 case 3: return [2 /*return*/];
+                case 4:
+                    if (event.origin !== targetOrigin && event.origin !== linkTokenOrigin) {
+                        console.warn('Received message from untrusted origin:', event.origin);
+                        return [2 /*return*/];
+                    }
+                    // No flow is live. An aborted re-open (`openLink` with a bad token, or
+                    // `openLinkBackup` with a bad origin) calls `backup.reset()` — clearing the
+                    // active-flow marker — but returns early WITHOUT removing the previous iframe or
+                    // this listener. A late `close`/`transferFinished` from that stale iframe still
+                    // passes the retained origin check, so gate on the POSITIVE active flow: drop
+                    // everything while no flow is active.
+                    if (backup.getActiveFlow() === null) {
+                        console.warn('Ignored message: no active Link flow');
+                        return [2 /*return*/];
+                    }
+                    // During a BACKUP flow, additionally require the message to come from the active
+                    // widget window — not just the backup ORIGIN. In embedded mode a reopen into a
+                    // different iframe leaves the previous one alive on the SAME backup origin, so an
+                    // origin-only check would let a late `close`/`done`/`transferFinished` from the
+                    // stale iframe tear down or report a transfer for the current session. A reopen
+                    // into the SAME embedded iframe keeps its window AND origin, so the message must
+                    // also echo this open's session nonce (`isFromActiveWidget`). (Primary flow has
+                    // no backup widget window, so it is gated by origin only, as before.)
+                    if (backup.getActiveFlow() === 'backup' &&
+                        !backup.isFromActiveWidget(event)) {
+                        console.warn('Ignored backup message from an unexpected source');
+                        return [2 /*return*/];
+                    }
+                    return [4 /*yield*/, handleLinkEvent(event)];
+                case 5:
+                    _a.sent();
+                    return [2 /*return*/];
             }
         });
     });
@@ -169,6 +267,9 @@ export var createLink = function (options) {
     var openLink = function (linkToken, customIframeId) {
         var _a, _b, _c;
         removePrewarmIframe();
+        // Clear any prior backup session so its config can't leak into the token
+        // path and its pending tier timer can't fire against this iframe.
+        backup.reset();
         if (!linkToken) {
             (_a = options === null || options === void 0 ? void 0 : options.onExit) === null || _a === void 0 ? void 0 : _a.call(options, 'Invalid link token!');
             return;
@@ -186,6 +287,9 @@ export var createLink = function (options) {
             (_c = options === null || options === void 0 ? void 0 : options.onExit) === null || _c === void 0 ? void 0 : _c.call(options, 'Invalid link token!');
             return;
         }
+        // Committed to the primary (token) flow — safe to forward access tokens on the
+        // `loaded` handshake. (`backup.reset()` above cleared any prior flow.)
+        backup.setPrimaryFlow();
         linkUrl = addLanguage(linkUrl, currentOptions === null || currentOptions === void 0 ? void 0 : currentOptions.language);
         linkUrl = addDisplayFiatCurrency(linkUrl, currentOptions === null || currentOptions === void 0 ? void 0 : currentOptions.displayFiatCurrency);
         linkUrl = addTheme(linkUrl, currentOptions === null || currentOptions === void 0 ? void 0 : currentOptions.theme);
@@ -196,6 +300,11 @@ export var createLink = function (options) {
             var iframe_1 = document.getElementById(customIframeId);
             if (iframe_1) {
                 iframe_1.allow = buildIframeAllowPolicy(linkTokenOrigin);
+                // Clear any leftover Tier-2 state from a prior backup session on this
+                // reused iframe: `srcdoc` (takes precedence over `src`) and the `sandbox`
+                // attribute (would otherwise keep it opaque-origin).
+                iframe_1.removeAttribute('srcdoc');
+                iframe_1.removeAttribute('sandbox');
                 iframe_1.src = linkUrl;
                 currentIframeId = customIframeId;
             }
@@ -214,11 +323,15 @@ export var createLink = function (options) {
             bridgeParent = new BridgeParent(iframe);
         }
     };
+    var openLinkBackup = function (session, backupOptions) {
+        backup.open(options, session, backupOptions);
+    };
     var closeLink = function () {
         var _a;
         bridgeParent === null || bridgeParent === void 0 ? void 0 : bridgeParent.destroy();
         removePopup();
         window.removeEventListener('message', eventsListener);
+        backup.reset();
         (_a = options.onExit) === null || _a === void 0 ? void 0 : _a.call(options);
     };
     var closeLinkRequested = function () {
@@ -231,6 +344,7 @@ export var createLink = function (options) {
     };
     return {
         openLink: openLink,
+        openLinkBackup: openLinkBackup,
         closeLink: closeLink,
         closeLinkRequested: closeLinkRequested
     };

package/README.md

@@ -94,26 +94,79 @@ After successfull authentication on the Link session, the popup will be closed a
 
 #### `createLink` arguments
 
-| key                      | type                                                   | description                                                                          |
-| ------------------------ | ------------------------------------------------------ | ------------------------------------------------------------------------------------ |
-| `onIntegrationConnected` | `(payload: LinkPayload) => void`                       | Callback called when users connects their accounts                                   |
-| `onExit`                 | `((error?: string \| undefined) => void) \| undefined` | Called if connection not happened                                                    |
-| `onTransferFinished`     | `(payload: TransferFinishedPayload) => void`           | Callback called when a crypto transfer is executed                                   |
-| `onEvent`                | `(payload: LinkEventType) => void`                     | A callback function that is called when various events occur within the Front iframe |
-| `accessTokens`           | `IntegrationAccessToken[]`                             | An array of integration access tokens                                                |
-| `language`               | `'en' \| undefined`                                    | Link UI language                                                                     |
-| `displayFiatCurrency`    | `'USD' \| undefined`                                   | A fiat currency to display fiat equivalent of a crypto amount                        |
-| `theme`                  | `'dark' \| 'light' \| 'system' \| undefined`           | Color theme of Link UI interface                                                     |
-| `renderType`             | `'overlay' \| 'embedded' \| undefined`                 | `'overlay'` (default) renders a full-screen popup; `'embedded'` renders inside a client-supplied iframe (requires `customIframeId` in `openLink`) |
+| key                      | type                                                        | description                                                                                                                                       |
+| ------------------------ | ----------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `onIntegrationConnected` | `((payload: LinkPayload) => void) \| undefined`             | Callback called when users connects their accounts                                                                                                |
+| `onExit`                 | `((error?: string \| undefined) => void) \| undefined`      | Called if connection not happened                                                                                                                 |
+| `onTransferFinished`     | `((payload: TransferFinishedPayload) => void) \| undefined` | Callback called when a crypto transfer is executed                                                                                                |
+| `onEvent`                | `((payload: LinkEventType) => void) \| undefined`           | A callback function that is called when various events occur within the Front iframe                                                              |
+| `accessTokens`           | `IntegrationAccessToken[]`                                  | An array of integration access tokens                                                                                                             |
+| `language`               | `'en' \| undefined`                                         | Link UI language                                                                                                                                  |
+| `displayFiatCurrency`    | `'USD' \| undefined`                                        | A fiat currency to display fiat equivalent of a crypto amount                                                                                     |
+| `theme`                  | `'dark' \| 'light' \| 'system' \| undefined`                | Color theme of Link UI interface                                                                                                                  |
+| `renderType`             | `'overlay' \| 'embedded' \| undefined`                      | `'overlay'` (default) renders a full-screen popup; `'embedded'` renders inside a client-supplied iframe (requires `customIframeId` in `openLink`) |
+
+All callbacks are optional.
+
+#### Withdrawal events
+
+When a user confirms a withdrawal, `onEvent` receives a `withdrawalRequested` event, then Link closes and calls `onExit`.
+With `renderType: 'embedded'`, the SDK does not remove your iframe: hide it in `onExit`.
+Keep the `transferId` and continue the withdrawal once Link has closed, for example with your own 2FA prompt.
+Treat the event, not `onExit`, as confirmation of the withdrawal.
+The payload carries no address or amount: read the transfer details from the webhook or the transfer API.
+
+```ts
+onEvent: event => {
+  if (event.type === 'withdrawalRequested') {
+    const { transferId, status } = event.payload // 'pending' or 'success'; treat any other value as pending
+  }
+}
+```
 
 #### `createLink` return value
 
 | key                  | type                                                        | description                                                                                                |
 | -------------------- | ----------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- |
 | `openLink`           | `(linkToken: string, customIframeId?: string) => void`      | Opens the Link UI popup. Optionally targets an existing iframe by ID instead of creating a new popup       |
+| `openLinkBackup`     | `(backupConfig: MeshBackupConfig, options?: MeshBackupOptions) => void` | Opens the deposit-only **backup flow** when the Mesh API is unavailable (see below)             |
 | `closeLink`          | `() => void`                                                | Closes the Link UI popup immediately                                                                       |
 | `closeLinkRequested` | `() => void`                                                | Requests graceful close in `embedded` mode (sends `closeRequested` to iframe); closes immediately otherwise  |
 
+### Backup / outage flow
+
+If a `linktoken` request fails in a way that indicates a Mesh outage (network/DNS error, timeout, HTTP 5xx or 429), you can open a **deposit-only backup flow** instead of the normal flow. It runs select-token → select-network → QR / copy-address from Mesh infrastructure on a separate domain, and resolves deposit addresses either from static config or through callbacks you provide.
+
+```ts
+const link = createLink({
+  onIntegrationConnected, onTransferFinished, onEvent, onExit,
+
+  // JIT callbacks — required only if any destination omits `address`. They run in
+  // YOUR app with YOUR session; only (symbol, networkId) and the resolved address
+  // cross the bridge. `fetch` resolves on 4xx/5xx, so throw on a non-OK response to
+  // fail closed.
+  onAddressInit: async (symbol, networkId) => {
+    const res = await api.post('/wallets/addresses/assign', { currency: symbol, network_id: networkId })
+    if (!res.ok) throw new Error('address init failed')
+  },
+  onStatusPoll: async (symbol, networkId) => {
+    const res = await api.get('/wallets/deposit_addresses', { currency: symbol })
+    if (!res.ok) throw new Error('status poll failed')
+    const m = (await res.json()).deposit_addresses.find(a => a.network_id === networkId && a.address)
+    return m ? { status: 'ready', address: m.address, addressTag: m.address_tag } : { status: 'pending' }
+  }
+})
+
+// Normal path:
+link.openLink(linkToken)
+// Outage path — same handlers, no link token:
+link.openLinkBackup(backupConfig)
+```
+
+Callbacks (`onAddressInit`, `onStatusPoll`) are passed to `createLink`. `onAddressInit(symbol, networkId)` kicks off generation (its return is ignored; a throw/reject is a failure). `onStatusPoll(symbol, networkId)` returns `Promise<{ status: 'pending' | 'ready' | 'failed'; address?; addressTag? }>` and is polled until `ready`/`failed`; it must be idempotent per `(symbol, networkId)`. Supply both only if any `backupConfig.destinations[]` entry omits `address`.
+
+> **⚠️ Host CSP requirements (web only).** Serve the embedding page over **https**. Your Content-Security-Policy's `frame-src`/`child-src` (or `default-src`) must allow **the backup widget origin** (`https://backup.meshconnect.com` by default) and **`blob:`** — the bundled last-resort fallback renders as a sandboxed `blob:` iframe, so a CSP that pins `frame-src` to the primary Mesh origin will block it and the fallback will fail. (React Native is not affected — it uses a native WebView, not an iframe.)
+
 ### Using tokens
 
 You can use broker tokens to perform requests to get current balance, assets and execute transactions. Full API reference can be found [here](https://integration-api.meshconnect.com/apireference).
@@ -134,6 +187,9 @@ TypeScript definitions for `@meshconnect/web-link-sdk` are built into the npm pa
 | `BrokerType`              | Union of supported broker/integration type strings (re-exported from `@meshconnect/node-api`) |
 | `LinkOptions`             | Full options object passed to `createLink`                                                    |
 | `Link`                    | Return type of `createLink`                                                                   |
+| `MeshBackupConfig`        | Config passed to `openLinkBackup` (clientId, userId, destinations, preselectedSymbol)         |
+| `MeshBackupOptions`       | Options for `openLinkBackup` (e.g. `customIframeId`, `widgetOrigin`)                           |
+| `MeshBackupStatusResult`  | Return type of the `onStatusPoll` callback                                                     |
 | `AccountToken`            | Account token within `AccessTokenPayload`                                                     |
 | `Account`                 | Account details within `AccountToken`                                                         |
 | `BrandInfo`               | Integration brand/logo info                                                                   |

package/backup-bundle/generated.d.ts

@@ -0,0 +1,2 @@
+/** Self-contained Tier-2 offline widget, loaded into a sandboxed blob: iframe. */
+export declare const OFFLINE_WIDGET_HTML: string;