@useragent-kit/sdk 0.0.0 → 0.0.1

package/dist/product-view.js

@@ -0,0 +1,2671 @@
+/**
+ * mountProductView — sandboxed iframe container for Polkadot product dApps.
+ *
+ * Works in web, Electron, and Tauri environments. The iframe is given
+ * `sandbox="allow-scripts"` — no same-origin access, no forms, no popups.
+ * Direct network access is blocked by default, with optional host-approved
+ * exact HTTPS origin exceptions. All communication happens through postMessage.
+ *
+ * @example
+ * ```ts
+ * const handle = mountProductView({
+ *   container: document.getElementById("app-frame")!,
+ *   productId: "com.example.myapp",
+ *   assets: assetsMap,
+ *   sdk,
+ *   delegate: {
+ *     onMessage(data, productId) {
+ *       const outcome = sdk.handleMessage(data, productId);
+ *       // ... handle outcome
+ *     },
+ *   },
+ * });
+ * // Later:
+ * handle.sendResponse(responseBytes);
+ * handle.destroy();
+ * ```
+ */
+import { createBridgeMetadata } from "./bridge/contract.js";
+import { isProductAnalyticsMessage } from "./telemetry.js";
+// ---------------------------------------------------------------------------
+// Internal bridge script adapted for iframe postMessage transport
+// ---------------------------------------------------------------------------
+const WEB_BRIDGE_SCRIPT = `
+(function() {
+    'use strict';
+    if (window.__hostApiBridge) { return; }
+    window.__hostApiBridge = true;
+    window.__HOST_WEBVIEW_MARK__ = true;
+    if (!window.host) { window.host = {}; }
+    if (!window.host.storage) { window.host.storage = {}; }
+    var __session = window.__HOST_PRODUCT_VIEW_SESSION__ || null;
+    var listeners = [];
+    var started = false;
+    var pending = [];
+    function dispatch(data) {
+        var ev = { data: data };
+        for (var i = 0; i < listeners.length; i++) {
+            try { listeners[i](ev); } catch(e) {}
+        }
+    }
+    window.__HOST_API_PORT__ = {
+        postMessage: function(data) {
+            var bytes;
+            if (data instanceof Uint8Array) { bytes = data; }
+            else if (data instanceof ArrayBuffer) { bytes = new Uint8Array(data); }
+            else if (ArrayBuffer.isView(data)) { bytes = new Uint8Array(data.buffer, data.byteOffset, data.byteLength); }
+            else { return; }
+            parent.postMessage({ type: 'hostapi', data: bytes, session: __session }, '*');
+        },
+        addEventListener: function(type, handler) {
+            if (type === 'message') { listeners.push(handler); }
+        },
+        removeEventListener: function(type, handler) {
+            if (type === 'message') {
+                listeners = listeners.filter(function(l) { return l !== handler; });
+            }
+        },
+        start: function() {
+            started = true;
+            for (var i = 0; i < pending.length; i++) { dispatch(pending[i]); }
+            pending = [];
+        }
+    };
+    window.addEventListener('message', function(ev) {
+        if (!ev.data || ev.data.type !== 'hostapi-reply') { return; }
+        if (__session && ev.data.session !== __session) { return; }
+        var data = ev.data.data;
+        if (started) { dispatch(data); } else { pending.push(data); }
+    });
+})();
+`;
+const HOST_PRODUCT_VIEW_SESSION_QUERY_KEY = "__hostsdk_session";
+function createProductViewSessionToken() {
+    if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+        return crypto.randomUUID().replace(/-/g, "");
+    }
+    return Math.random().toString(36).slice(2, 18);
+}
+function buildProductViewSessionBootstrapScript() {
+    return `(function() {
+    'use strict';
+    var token = null;
+    try {
+      var params = new URLSearchParams(window.location.search);
+      token = params.get("${HOST_PRODUCT_VIEW_SESSION_QUERY_KEY}");
+    } catch (e) {}
+    if (!token) { return; }
+    try {
+      Object.defineProperty(window, "__HOST_PRODUCT_VIEW_SESSION__", {
+        value: token,
+        writable: false,
+        configurable: false,
+        enumerable: false,
+      });
+    } catch (e) {
+      try { window.__HOST_PRODUCT_VIEW_SESSION__ = token; } catch (e2) {}
+    }
+    try {
+      if (history && history.replaceState) {
+        var nextSearch = "";
+        try {
+          var nextParams = new URLSearchParams(window.location.search);
+          nextParams.delete("${HOST_PRODUCT_VIEW_SESSION_QUERY_KEY}");
+          var encoded = nextParams.toString();
+          nextSearch = encoded ? "?" + encoded : "";
+        } catch (e2) {}
+        history.replaceState(null, "", location.pathname + nextSearch + location.hash);
+      }
+    } catch (e) {}
+  })();`;
+}
+/**
+ * Build the web iframe bridge script.
+ *
+ * Uses `WEB_BRIDGE_SCRIPT` which creates a shim `window.__HOST_API_PORT__`
+ * that communicates with the host via `parent.postMessage` directly (raw
+ * Uint8Array, no base64 encoding, no MessageChannel indirection).
+ *
+ * Security note: `'*'` is unavoidable in the iframe-to-host direction
+ * because the sandboxed iframe (no allow-same-origin) has an opaque `null`
+ * origin and cannot know its parent's origin. The host-side security
+ * boundary is the `event.source === iframe.contentWindow` check in
+ * mountProductView's `onMessage` handler.
+ *
+ * For host-to-iframe replies the host uses `'null'` as the targetOrigin
+ * (srcdoc) or the real frame origin (URL-backed). This restricts delivery
+ * to the correct iframe.
+ *
+ * @internal Exported for testing only -- not part of the public API.
+ */
+export function buildIframeBridgeScript(interactive = false) {
+    // Grant port setup is only needed for interactive sandbox mode.
+    const grantPortSetup = interactive
+        ? `
+    var grantCh = new MessageChannel();
+    window.__HOST_SANDBOX_GRANT_PORT__ = grantCh.port2;
+    grantCh.port2.start();
+    try {
+        parent.postMessage({ type: 'hostapi-grant-port', session: window.__HOST_PRODUCT_VIEW_SESSION__ || null }, '*', [grantCh.port1]);
+    } catch (e) {}`
+        : "";
+    return WEB_BRIDGE_SCRIPT.replace("})();", `${grantPortSetup}
+    function __emitHostHeartbeat() {
+        try {
+            parent.postMessage({ type: 'hostapi-heartbeat', session: window.__HOST_PRODUCT_VIEW_SESSION__ || null }, '*');
+        } catch (e) {}
+    }
+    __emitHostHeartbeat();
+    window.setInterval(__emitHostHeartbeat, 500);
+})();`);
+}
+/**
+ * Build a script that installs the stable `window.host` bridge surface in the
+ * sandboxed iframe. Each method routes through a JSON postMessage channel to
+ * the host frame.
+ *
+ * Must be injected AFTER `buildIframeBridgeScript()` (which creates
+ * `window.host`) and BEFORE `buildBridgeMetadataScript()` and the sandbox
+ * lockdown script.
+ *
+ * @internal Exported for testing only — not part of the public API.
+ */
+export function buildStableBridgeScript() {
+    return `(function() {
+    'use strict';
+    if (!window.host) { window.host = {}; }
+    var __session = window.__HOST_PRODUCT_VIEW_SESSION__ || null;
+    var callId = 0;
+    var pending = {};
+    var listeners = {};
+
+    function bridgeCall(method, args) {
+      return new Promise(function(resolve, reject) {
+        var id = ++callId;
+        pending[id] = { resolve: resolve, reject: reject };
+        parent.postMessage({ type: 'host-bridge-call', callId: id, method: method, args: args, session: __session }, '*');
+      });
+    }
+
+    window.addEventListener('message', function(ev) {
+      if (!ev.data) { return; }
+      if (ev.data.type === 'host-bridge-reply') {
+        if (__session && ev.data.session !== __session) { return; }
+        var p = pending[ev.data.callId];
+        if (p) {
+          delete pending[ev.data.callId];
+          if (ev.data.error) {
+            var err = new Error(ev.data.error);
+            err.code = ev.data.errorCode || 'ERR_HOST_RUNTIME_UNAVAILABLE';
+            p.reject(err);
+          } else {
+            p.resolve(ev.data.result);
+          }
+        }
+      } else if (ev.data.type === 'host-bridge-event') {
+        var cbs = listeners[ev.data.event];
+        if (cbs) {
+          for (var i = 0; i < cbs.length; i++) {
+            try { cbs[i](ev.data.payload); } catch (e) {}
+          }
+        }
+      }
+    });
+
+    window.host.getAddress = function() {
+      return bridgeCall('getAddress', []);
+    };
+
+    if (!window.host.storage) { window.host.storage = {}; }
+    window.host.storage.get = function(key) {
+      return bridgeCall('storage.get', [key]);
+    };
+    window.host.storage.set = function(key, value) {
+      return bridgeCall('storage.set', [key, value]);
+    };
+    window.host.storage.remove = function(key) {
+      return bridgeCall('storage.remove', [key]);
+    };
+
+    if (!window.host.statements) { window.host.statements = {}; }
+    window.host.statements.subscribe = function(channel) {
+      return bridgeCall('statements.subscribe', [channel]);
+    };
+    window.host.statements.write = function(channel, data) {
+      return bridgeCall('statements.write', [channel, data]);
+    };
+    window.host.statements.status = function() {
+      return bridgeCall('statements.status', []);
+    };
+
+    if (!window.host.identity) { window.host.identity = {}; }
+    window.host.identity.resolveUsername = function(username) {
+      return bridgeCall('identity.resolveUsername', [username]);
+    };
+
+    window.host.on = function(event, callback) {
+      if (!listeners[event]) { listeners[event] = []; }
+      listeners[event].push(callback);
+    };
+    window.host.off = function(event, callback) {
+      var cbs = listeners[event];
+      if (!cbs) { return; }
+      var idx = cbs.indexOf(callback);
+      if (idx !== -1) { cbs.splice(idx, 1); }
+    };
+
+    window.host.destroy = function() {
+      // Lifecycle management belongs to the host frame; guest-side no-op.
+    };
+  })();`;
+}
+/**
+ * Build a bootstrap script that exposes immutable `window.host.__bridge`
+ * metadata before product code and extension scripts run.
+ *
+ * The current web `srcdoc` profile still uses the binary host-api port for its
+ * core transport, so only extension capabilities are advertised here.
+ *
+ * @internal Exported for testing only — not part of the public API.
+ */
+export function buildBridgeMetadataScript(extensionInjectScript, profile = "web-srcdoc", coreCapabilities) {
+    const metadata = createBridgeMetadata({
+        profile,
+        coreCapabilities: {
+            storage: coreCapabilities?.storage ?? false,
+            statements: coreCapabilities?.statements ?? false,
+        },
+        extCapabilities: {
+            claw: extensionInjectScript.includes("window.host.ext.claw"),
+            data: extensionInjectScript.includes("window.host.ext.data"),
+            media: extensionInjectScript.includes("window.host.ext.media"),
+            files: extensionInjectScript.includes("window.host.ext.files"),
+            mesh: extensionInjectScript.includes("window.host.ext.mesh"),
+            vrf: extensionInjectScript.includes("window.host.ext.vrf"),
+        },
+    }, coreCapabilities?.identity ?? false);
+    const metadataJson = JSON.stringify(metadata);
+    return `(function() {
+    'use strict';
+    if (!window.host) { window.host = {}; }
+    if (Object.prototype.hasOwnProperty.call(window.host, '__bridge')) { return; }
+    var metadata = ${metadataJson};
+    if (Object.freeze) {
+      try {
+        Object.freeze(metadata.productProtocol);
+        Object.freeze(metadata.capabilities.ext);
+        Object.freeze(metadata.capabilities);
+        Object.freeze(metadata);
+      } catch (e) {}
+    }
+    Object.defineProperty(window.host, '__bridge', {
+      value: metadata,
+      writable: false,
+      configurable: false,
+      enumerable: true,
+    });
+  })();`;
+}
+/**
+ * Build a script that injects `window.__HOST_TRACE_CONTEXT__` into the iframe.
+ *
+ * The object is frozen to prevent product code from tampering with it.
+ * Only injected when the host provides a `traceContext` in mount options.
+ *
+ * @internal Exported for testing only — not part of the public API.
+ */
+export function buildTraceContextScript(ctx) {
+    const json = JSON.stringify({
+        traceId: ctx.traceId,
+        parentSpanId: ctx.parentSpanId,
+        sampled: ctx.sampled,
+        ...(ctx.productId ? { productId: ctx.productId } : {}),
+    });
+    return `(function() {
+    'use strict';
+    var ctx = ${json};
+    if (Object.freeze) { try { Object.freeze(ctx); } catch(e) {} }
+    Object.defineProperty(window, '__HOST_TRACE_CONTEXT__', {
+      value: ctx,
+      writable: false,
+      configurable: false,
+      enumerable: false,
+    });
+  })();`;
+}
+/** Sandbox attribute applied to the product iframe. */
+export const IFRAME_SANDBOX_ATTR = "allow-scripts";
+export const URL_BACKED_IFRAME_SANDBOX_ATTR = "allow-scripts allow-same-origin";
+function normalizeApprovedNetworkOrigins(origins = []) {
+    const seen = new Set();
+    const normalized = [];
+    for (const origin of origins) {
+        if (typeof origin !== "string" || !origin.startsWith("https://"))
+            continue;
+        const rest = origin.slice("https://".length);
+        if (rest.length === 0 ||
+            rest.includes("/") ||
+            rest.includes("?") ||
+            rest.includes("#") ||
+            rest.includes("*") ||
+            rest.includes(" ") ||
+            rest.startsWith(":") ||
+            rest.endsWith(":")) {
+            continue;
+        }
+        if (seen.has(origin))
+            continue;
+        seen.add(origin);
+        normalized.push(origin);
+    }
+    return normalized;
+}
+function normalizeApprovedWebSocketOrigins(origins = []) {
+    const seen = new Set();
+    const normalized = [];
+    for (const origin of origins) {
+        if (typeof origin !== "string" || !origin.startsWith("wss://"))
+            continue;
+        const rest = origin.slice("wss://".length);
+        if (rest.length === 0 ||
+            rest.includes("/") ||
+            rest.includes("?") ||
+            rest.includes("#") ||
+            rest.includes("*") ||
+            rest.includes(" ") ||
+            rest.startsWith(":") ||
+            rest.endsWith(":")) {
+            continue;
+        }
+        if (seen.has(origin))
+            continue;
+        seen.add(origin);
+        normalized.push(origin);
+    }
+    return normalized;
+}
+function normalizeApprovedWebRtcServerUrls(urls = []) {
+    const seen = new Set();
+    const normalized = [];
+    for (const rawUrl of urls) {
+        if (typeof rawUrl !== "string")
+            continue;
+        const trimmed = rawUrl.trim();
+        if (!/^(stun|turn|turns):/i.test(trimmed))
+            continue;
+        if (trimmed.includes("?") || trimmed.includes("#") || trimmed.includes(" "))
+            continue;
+        if (seen.has(trimmed))
+            continue;
+        seen.add(trimmed);
+        normalized.push(trimmed);
+    }
+    return normalized;
+}
+export function buildIframeCsp(approvedNetworkOrigins = [], approvedWebSocketOrigins = []) {
+    const connectSrc = [
+        ...normalizeApprovedNetworkOrigins(approvedNetworkOrigins),
+        ...normalizeApprovedWebSocketOrigins(approvedWebSocketOrigins),
+    ];
+    const connectDirective = connectSrc.length === 0 ? "'none'" : connectSrc.join(" ");
+    return ("default-src 'none'; " +
+        "script-src 'unsafe-inline' 'wasm-unsafe-eval' data: blob:; " +
+        "style-src 'unsafe-inline'; " +
+        "frame-src 'none'; " +
+        `connect-src ${connectDirective}; ` +
+        "img-src blob: data:; " +
+        "font-src 'none'; " +
+        "media-src 'none'; " +
+        "object-src 'none'; " +
+        "base-uri 'none'; " +
+        "form-action 'none'");
+}
+export const IFRAME_CSP = buildIframeCsp();
+/** Synthetic absolute origin used only when rewriting srcdoc bundle URLs. */
+const SYNTHETIC_PRODUCT_BUNDLE_ORIGIN = "https://product.bundle.invalid";
+export function buildUrlBackedIframeCsp(approvedNetworkOrigins = [], approvedWebSocketOrigins = []) {
+    const connectSrc = [
+        ...normalizeApprovedNetworkOrigins(approvedNetworkOrigins),
+        ...normalizeApprovedWebSocketOrigins(approvedWebSocketOrigins),
+    ];
+    const connectDirective = connectSrc.length === 0 ? "'self'" : ["'self'", ...connectSrc].join(" ");
+    return ("default-src 'none'; " +
+        "script-src 'self' 'unsafe-inline' 'wasm-unsafe-eval' data: blob:; " +
+        "style-src 'self' 'unsafe-inline'; " +
+        "frame-src 'none'; " +
+        `connect-src ${connectDirective}; ` +
+        "img-src 'self' blob: data:; " +
+        "font-src 'self'; " +
+        "media-src 'none'; " +
+        "object-src 'none'; " +
+        "base-uri 'self'; " +
+        "form-action 'none'");
+}
+function buildAllowedNetworkHelpers(approvedNetworkOrigins, approvedWebSocketOrigins = [], approvedWebRtcServerUrls = []) {
+    const allowed = JSON.stringify(normalizeApprovedNetworkOrigins(approvedNetworkOrigins));
+    const allowedWebSockets = JSON.stringify(normalizeApprovedWebSocketOrigins(approvedWebSocketOrigins));
+    const allowedWebRtcServers = JSON.stringify(normalizeApprovedWebRtcServerUrls(approvedWebRtcServerUrls));
+    return `
+    var __approvedNetworkOrigins = ${allowed};
+    var __approvedWebSocketOrigins = ${allowedWebSockets};
+    var __approvedWebRtcServerUrls = ${allowedWebRtcServers};
+    function __isApprovedNetworkUrl(input) {
+        try {
+            var parsed = new URL(String(input), location.href);
+            return parsed.protocol === 'https:' &&
+                __approvedNetworkOrigins.indexOf(parsed.origin) !== -1;
+        } catch (e) {
+            return false;
+        }
+    }
+    function __extractApprovedWebSocketOrigin(input) {
+        try {
+            var parsed = new URL(String(input), location.href);
+            if (parsed.protocol !== 'wss:') { return null; }
+            return parsed.origin;
+        } catch (e) {
+            return null;
+        }
+    }
+    function __isApprovedWebSocketUrl(input) {
+        var origin = __extractApprovedWebSocketOrigin(input);
+        return origin !== null && __approvedWebSocketOrigins.indexOf(origin) !== -1;
+    }
+    function __normalizeWebRtcServerUrl(input) {
+        if (typeof input !== 'string') { return null; }
+        var trimmed = input.trim();
+        if (!/^(stun|turn|turns):/i.test(trimmed)) { return null; }
+        if (trimmed.indexOf('?') !== -1 || trimmed.indexOf('#') !== -1 || trimmed.indexOf(' ') !== -1) {
+            return null;
+        }
+        return trimmed;
+    }
+    function __extractFirstWebRtcServerUrl(config) {
+        if (!config || !config.iceServers) { return null; }
+        var iceServers = Array.isArray(config.iceServers) ? config.iceServers : [config.iceServers];
+        for (var i = 0; i < iceServers.length; i++) {
+            var entry = iceServers[i];
+            if (!entry) { continue; }
+            var urls = entry.urls;
+            if (Array.isArray(urls) && urls.length > 0) {
+                return __normalizeWebRtcServerUrl(String(urls[0]));
+            }
+            if (typeof urls === 'string') {
+                return __normalizeWebRtcServerUrl(urls);
+            }
+            if (typeof entry.url === 'string') {
+                return __normalizeWebRtcServerUrl(entry.url);
+            }
+        }
+        return null;
+    }
+    function __isApprovedWebRtcConfiguration(config) {
+        if (!config || !config.iceServers) { return false; }
+        var iceServers = Array.isArray(config.iceServers) ? config.iceServers : [config.iceServers];
+        if (iceServers.length === 0) { return false; }
+        for (var i = 0; i < iceServers.length; i++) {
+            var entry = iceServers[i];
+            if (!entry) { return false; }
+            var urls = entry.urls;
+            var values = Array.isArray(urls)
+                ? urls
+                : (typeof urls === 'string' ? [urls] : (typeof entry.url === 'string' ? [entry.url] : []));
+            if (values.length === 0) { return false; }
+            for (var j = 0; j < values.length; j++) {
+                var normalizedUrl = __normalizeWebRtcServerUrl(String(values[j]));
+                if (!normalizedUrl || __approvedWebRtcServerUrls.indexOf(normalizedUrl) === -1) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+  `;
+}
+function buildNavigationGuardBlock(mode) {
+    const rejectNavigation = mode === "lockdown"
+        ? `
+            throw new DOMException(
+                'navigation to javascript: and data: URLs is blocked in sandboxed products', 'SecurityError'
+            );`
+        : mode === "monitor"
+            ? `
+            reportAndThrow('Navigation', { url: blocked });
+            return;`
+            : `
+            report('Navigation', { url: blocked }, 'always_blocked');
+            return;`;
+    return `
+    function __blockedNavigationTarget(input) {
+        if (typeof input !== 'string') { return null; }
+        var normalized = input.trim();
+        return /^(javascript|data):/i.test(normalized) ? normalized : null;
+    }
+    function __patchLocationMethod(target, name) {
+        if (!target) { return; }
+        try {
+            var original = target[name];
+            if (typeof original !== 'function') { return; }
+            Object.defineProperty(target, name, {
+                value: function(url) {
+                    var blocked = __blockedNavigationTarget(String(url));
+                    if (blocked) {${rejectNavigation}
+                    }
+                    return original.apply(window.location, arguments);
+                },
+                writable: false,
+                configurable: false,
+            });
+        } catch (e) {}
+    }
+    function __patchLocationHref(target) {
+        if (!target) { return; }
+        try {
+            var descriptor = Object.getOwnPropertyDescriptor(target, 'href');
+            if (!descriptor || typeof descriptor.set !== 'function') { return; }
+            Object.defineProperty(target, 'href', {
+                get: descriptor.get ? function() { return descriptor.get.call(window.location); } : undefined,
+                set: function(url) {
+                    var blocked = __blockedNavigationTarget(String(url));
+                    if (blocked) {${rejectNavigation}
+                    }
+                    return descriptor.set.call(window.location, url);
+                },
+                configurable: false,
+            });
+        } catch (e) {}
+    }
+    var __locationProto = Object.getPrototypeOf(window.location);
+    __patchLocationMethod(__locationProto, 'assign');
+    __patchLocationMethod(__locationProto, 'replace');
+    __patchLocationMethod(window.location, 'assign');
+    __patchLocationMethod(window.location, 'replace');
+    __patchLocationHref(__locationProto);
+    __patchLocationHref(window.location);
+  `;
+}
+/**
+ * Production lockdown script: neutralise browser APIs that could exfiltrate
+ * data or establish out-of-band connections. Silently blocks without reporting.
+ *
+ * Mirrors `SANDBOX_LOCKDOWN_SCRIPT` from `host-product-view/src/security.rs`.
+ */
+export function buildLockdownScript(approvedNetworkOrigins = [], approvedWebSocketOrigins = [], approvedWebRtcServerUrls = []) {
+    const normalized = normalizeApprovedNetworkOrigins(approvedNetworkOrigins);
+    const normalizedWebSockets = normalizeApprovedWebSocketOrigins(approvedWebSocketOrigins);
+    const normalizedWebRtc = normalizeApprovedWebRtcServerUrls(approvedWebRtcServerUrls);
+    const remoteHelpers = normalized.length > 0 || normalizedWebSockets.length > 0 || normalizedWebRtc.length > 0
+        ? buildAllowedNetworkHelpers(normalized, normalizedWebSockets, normalizedWebRtc)
+        : "";
+    const navigationSetup = buildNavigationGuardBlock("lockdown");
+    const networkSetup = normalized.length === 0
+        ? `
+    var _origFetch = window.fetch;
+    if (_origFetch) {
+        window.fetch = function(input, init) {
+            var url = (typeof input === 'string') ? input : (input && input.url ? input.url : String(input));
+            var parsed = new URL(url, location.href);
+            // In a sandboxed srcdoc iframe location.origin is the string "null";
+            // the origin comparison would be a no-op, so we block all requests.
+            if (location.origin === 'null' || parsed.origin !== location.origin) {
+                throw new DOMException(
+                    'fetch is blocked for cross-origin requests in sandboxed products', 'SecurityError'
+                );
+            }
+            return _origFetch.apply(this, arguments);
+        };
+    }
+    if (window.XMLHttpRequest && window.XMLHttpRequest.prototype && window.XMLHttpRequest.prototype.open) {
+        var _origXhrOpen = window.XMLHttpRequest.prototype.open;
+        window.XMLHttpRequest.prototype.open = function(method, url) {
+            var parsed = new URL(String(url), location.href);
+            // In a sandboxed srcdoc iframe location.origin is the string "null";
+            // the origin comparison would be a no-op, so we block all requests.
+            if (location.origin === 'null' || parsed.origin !== location.origin) {
+                throw new DOMException(
+                    'XMLHttpRequest is blocked for cross-origin requests in sandboxed products', 'SecurityError'
+                );
+            }
+            return _origXhrOpen.apply(this, arguments);
+        };
+    }
+`
+        : `
+    var _origFetch = window.fetch;
+    if (_origFetch) {
+        window.fetch = function(input, init) {
+            var url = (typeof input === 'string') ? input : (input && input.url ? input.url : String(input));
+            if (!__isApprovedNetworkUrl(url)) {
+                throw new DOMException(
+                    'fetch is blocked for unapproved origins in sandboxed products', 'SecurityError'
+                );
+            }
+            return _origFetch.apply(this, arguments);
+        };
+    }
+    if (window.XMLHttpRequest && window.XMLHttpRequest.prototype && window.XMLHttpRequest.prototype.open) {
+        var _origXhrOpen = window.XMLHttpRequest.prototype.open;
+        window.XMLHttpRequest.prototype.open = function(method, url) {
+            if (!__isApprovedNetworkUrl(url)) {
+                throw new DOMException(
+                    'XMLHttpRequest is blocked for unapproved origins in sandboxed products', 'SecurityError'
+                );
+            }
+            return _origXhrOpen.apply(this, arguments);
+        };
+    }
+`;
+    const webSocketSetup = normalizedWebSockets.length === 0
+        ? `try { window.WebSocket = undefined; } catch(e) {}`
+        : `
+    var _origWebSocket = window.WebSocket;
+    if (_origWebSocket) {
+        window.WebSocket = function(url, protocols) {
+            if (!__isApprovedWebSocketUrl(url)) {
+                throw new DOMException(
+                    'WebSocket is blocked for unapproved origins in sandboxed products', 'SecurityError'
+                );
+            }
+            return new _origWebSocket(url, protocols);
+        };
+        window.WebSocket.prototype = _origWebSocket.prototype;
+    }`;
+    const webRtcSetup = normalizedWebRtc.length === 0
+        ? `
+    try { window.RTCPeerConnection = undefined; } catch(e) {}
+    try { window.RTCSessionDescription = undefined; } catch(e) {}
+    try { window.RTCIceCandidate = undefined; } catch(e) {}
+    try { window.RTCDataChannel = undefined; } catch(e) {}`
+        : `
+    var _origRTCPeerConnection = window.RTCPeerConnection;
+    if (_origRTCPeerConnection) {
+        window.RTCPeerConnection = function(config, constraints) {
+            if (!__isApprovedWebRtcConfiguration(config)) {
+                throw new DOMException(
+                    'RTCPeerConnection is blocked for unapproved ICE servers in sandboxed products', 'SecurityError'
+                );
+            }
+            return new _origRTCPeerConnection(config, constraints);
+        };
+        window.RTCPeerConnection.prototype = _origRTCPeerConnection.prototype;
+    }`;
+    return `(function() {
+    'use strict';
+    ${remoteHelpers}
+    ${navigationSetup}
+
+    // Network APIs
+    ${webSocketSetup}
+    try { window.EventSource = undefined; } catch(e) {}
+    try { window.Worker = undefined; } catch(e) {}
+    ${networkSetup}
+
+    var __serviceWorker;
+    try { __serviceWorker = navigator.serviceWorker; } catch (e) { __serviceWorker = null; }
+    if (__serviceWorker) {
+        try {
+            Object.defineProperty(navigator, 'serviceWorker', {
+                get: function() {
+                    throw new DOMException(
+                        'serviceWorker is blocked in sandboxed products', 'SecurityError'
+                    );
+                },
+                configurable: false,
+            });
+        } catch (e) { /* already non-configurable on this engine — silently accept */ }
+    }
+
+    if (navigator.sendBeacon) {
+        try {
+            Object.defineProperty(navigator, 'sendBeacon', {
+                value: function() { return false; },
+                writable: false,
+                configurable: false,
+            });
+        } catch (e) { /* already non-configurable on this engine — silently accept */ }
+    }
+
+    // WebRTC
+    ${webRtcSetup}
+
+    // Cross-product communication
+    try { window.SharedWorker = undefined; } catch(e) {}
+    try { window.BroadcastChannel = undefined; } catch(e) {}
+
+    // localStorage — products must use the host bridge for persistence
+    try {
+        Object.defineProperty(window, 'localStorage', {
+            get: function() {
+                throw new DOMException(
+                    'localStorage is blocked in sandboxed products; use the host bridge', 'SecurityError'
+                );
+            },
+            configurable: false,
+        });
+    } catch (e) {}
+
+    if (window.caches) {
+        try {
+            Object.defineProperty(window.caches, 'open', {
+                value: function() {
+                    throw new DOMException('caches.open is blocked in sandboxed products', 'SecurityError');
+                },
+                writable: false,
+                configurable: false,
+            });
+        } catch (e) {}
+        try {
+            Object.defineProperty(window.caches, 'delete', {
+                value: function() {
+                    throw new DOMException('caches.delete is blocked in sandboxed products', 'SecurityError');
+                },
+                writable: false,
+                configurable: false,
+            });
+        } catch (e) {}
+    }
+
+    // Cookies
+    try {
+        Object.defineProperty(document, 'cookie', {
+            get: function() { return ''; },
+            set: function() {},
+            configurable: false,
+        });
+    } catch (e) {}
+
+    // Wallet extension sniffing
+    ['injectedWeb3', 'polkadot', 'ethereum'].forEach(function(key) {
+        try {
+            Object.defineProperty(window, key, {
+                value: undefined,
+                writable: false,
+                configurable: false,
+            });
+        } catch (e) {}
+    });
+
+    // Nested iframes — CSP meta tags don't propagate to child frames.
+    var _origCreateElement = document.createElement.bind(document);
+    document.createElement = function(tag) {
+        if (tag && tag.toLowerCase() === 'iframe') {
+            throw new DOMException('iframe creation is blocked in sandboxed products', 'SecurityError');
+        }
+        return _origCreateElement.apply(this, arguments);
+    };
+    // createElementNS is a separate code path that also produces elements.
+    var _origCreateElementNS = document.createElementNS.bind(document);
+    document.createElementNS = function(ns, tag) {
+        if (tag && tag.toLowerCase() === 'iframe') {
+            throw new DOMException('iframe creation is blocked in sandboxed products', 'SecurityError');
+        }
+        return _origCreateElementNS.apply(this, arguments);
+    };
+})();`;
+}
+export const LOCKDOWN_SCRIPT = buildLockdownScript();
+/**
+ * Development monitor script: wraps every blocked API with an instrumented stub
+ * that sends a SANDBOX_VIOLATION postMessage before throwing SecurityError.
+ *
+ * Use this instead of LOCKDOWN_SCRIPT during development by passing
+ * `enableViolationMonitor: true` to `mountProductView`.
+ *
+ * Mirrors `SANDBOX_MONITOR_SCRIPT` from `host-product-view/src/security.rs`.
+ */
+export function buildMonitorScript(approvedNetworkOrigins = [], approvedWebSocketOrigins = [], approvedWebRtcServerUrls = []) {
+    const normalized = normalizeApprovedNetworkOrigins(approvedNetworkOrigins);
+    const normalizedWebSockets = normalizeApprovedWebSocketOrigins(approvedWebSocketOrigins);
+    const normalizedWebRtc = normalizeApprovedWebRtcServerUrls(approvedWebRtcServerUrls);
+    const remoteHelpers = normalized.length > 0 || normalizedWebSockets.length > 0 || normalizedWebRtc.length > 0
+        ? buildAllowedNetworkHelpers(normalized, normalizedWebSockets, normalizedWebRtc)
+        : "";
+    const navigationSetup = buildNavigationGuardBlock("monitor");
+    const networkSetup = normalized.length === 0
+        ? `
+    var _origFetch = window.fetch;
+    if (_origFetch) {
+        window.fetch = function(input, init) {
+            var url;
+            try {
+                url = (typeof input === 'string') ? input : (input.url || String(input));
+                var parsed = new URL(url, location.href);
+                // In a sandboxed srcdoc iframe location.origin is the string "null";
+                // always report since origin comparison is a no-op in that context.
+                if (location.origin === 'null' || parsed.origin !== location.origin) {
+                    report('fetch', { url: url, origin: parsed.origin });
+                }
+            } catch (e) {
+                report('fetch', { url: String(url) });
+            }
+            return _origFetch.apply(this, arguments);
+        };
+    }
+
+    var _origXhrOpen = XMLHttpRequest.prototype.open;
+    if (_origXhrOpen) {
+        XMLHttpRequest.prototype.open = function(method, url) {
+            try {
+                var parsed = new URL(String(url), location.href);
+                // In a sandboxed srcdoc iframe location.origin is the string "null";
+                // always report since origin comparison is a no-op in that context.
+                if (location.origin === 'null' || parsed.origin !== location.origin) {
+                    report('XMLHttpRequest', { method: String(method), url: String(url), origin: parsed.origin });
+                }
+            } catch (e) {
+                report('XMLHttpRequest', { method: String(method), url: String(url) });
+            }
+            return _origXhrOpen.apply(this, arguments);
+        };
+    }
+`
+        : `
+    var _origFetch = window.fetch;
+    if (_origFetch) {
+        window.fetch = function(input, init) {
+            var url = (typeof input === 'string') ? input : (input && input.url ? input.url : String(input));
+            if (!__isApprovedNetworkUrl(url)) {
+                report('fetch', { url: String(url) });
+            }
+            return _origFetch.apply(this, arguments);
+        };
+    }
+
+    var _origXhrOpen = XMLHttpRequest.prototype.open;
+    if (_origXhrOpen) {
+        XMLHttpRequest.prototype.open = function(method, url) {
+            if (!__isApprovedNetworkUrl(url)) {
+                report('XMLHttpRequest', { method: String(method), url: String(url) });
+            }
+            return _origXhrOpen.apply(this, arguments);
+        };
+    }
+`;
+    const webSocketSetup = normalizedWebSockets.length === 0
+        ? `window.WebSocket = function(url) { reportAndThrow('WebSocket', { url: String(url) }); };`
+        : `
+    var _origWebSocket = window.WebSocket;
+    if (_origWebSocket) {
+        window.WebSocket = function(url, protocols) {
+            if (!__isApprovedWebSocketUrl(url)) {
+                reportAndThrow('WebSocket', { origin: __extractApprovedWebSocketOrigin(url) || String(url) });
+            }
+            return new _origWebSocket(url, protocols);
+        };
+        window.WebSocket.prototype = _origWebSocket.prototype;
+    }`;
+    const webRtcSetup = normalizedWebRtc.length === 0
+        ? `
+    window.RTCPeerConnection = function() { reportAndThrow('RTCPeerConnection', {}); };
+    window.RTCSessionDescription = function() { reportAndThrow('RTCSessionDescription', {}); };
+    window.RTCIceCandidate = function() { reportAndThrow('RTCIceCandidate', {}); };
+    window.RTCDataChannel = function() { reportAndThrow('RTCDataChannel', {}); };`
+        : `
+    var _origRTCPeerConnection = window.RTCPeerConnection;
+    if (_origRTCPeerConnection) {
+        window.RTCPeerConnection = function(config, constraints) {
+            if (!__isApprovedWebRtcConfiguration(config)) {
+                reportAndThrow('RTCPeerConnection', { server: __extractFirstWebRtcServerUrl(config) || 'unknown' });
+            }
+            return new _origRTCPeerConnection(config, constraints);
+        };
+        window.RTCPeerConnection.prototype = _origRTCPeerConnection.prototype;
+    }`;
+    return `(function() {
+    'use strict';
+    ${remoteHelpers}
+
+    // report() only sends the violation postMessage — it does NOT throw.
+    // In monitor mode the intent is to observe, not block. Network wrappers
+    // call report() and then proceed with the original request. Hard-blocked
+    // APIs (storage, WebSocket, etc.) use reportAndThrow() instead.
+    function report(api, details) {
+        var payload = {
+            type: 'SANDBOX_VIOLATION',
+            api: api,
+            details: details || {},
+            timestamp: Date.now(),
+        };
+        try {
+            var target = (window.parent !== window) ? window.parent : window;
+            target.postMessage(payload, '*');
+        } catch (e) {}
+    }
+
+    function reportAndThrow(api, details) {
+        report(api, details);
+        throw new DOMException(api + ' is blocked in sandboxed products', 'SecurityError');
+    }
+
+    ${navigationSetup}
+
+    // Network APIs
+    ${webSocketSetup}
+    window.EventSource = function(url) { reportAndThrow('EventSource', { url: String(url) }); };
+    window.Worker = function(url) { reportAndThrow('Worker', { url: String(url) }); };
+
+    var __serviceWorker;
+    try { __serviceWorker = navigator.serviceWorker; } catch (e) { __serviceWorker = null; }
+    if (__serviceWorker) {
+        try {
+            Object.defineProperty(navigator, 'serviceWorker', {
+                get: function() { reportAndThrow('ServiceWorker', {}); },
+                configurable: false,
+            });
+        } catch (e) { /* already non-configurable on this engine — silently accept */ }
+    }
+    ${networkSetup}
+
+    if (navigator.sendBeacon) {
+        try {
+            Object.defineProperty(navigator, 'sendBeacon', {
+                value: function(url) { reportAndThrow('sendBeacon', { url: String(url) }); },
+                writable: false,
+                configurable: false,
+            });
+        } catch (e) { /* already non-configurable on this engine — silently accept */ }
+    }
+
+    // WebRTC
+    ${webRtcSetup}
+
+    // Cross-product communication
+    window.SharedWorker = function(url) { reportAndThrow('SharedWorker', { url: String(url) }); };
+    window.BroadcastChannel = function(name) { reportAndThrow('BroadcastChannel', { name: String(name) }); };
+
+    // Storage
+    try {
+        Object.defineProperty(window, 'localStorage', {
+            get: function() { reportAndThrow('localStorage', {}); },
+            configurable: false,
+        });
+    } catch (e) {}
+
+    if (window.caches) {
+        try {
+            Object.defineProperty(window.caches, 'open', {
+                value: function(cacheName) { reportAndThrow('caches.open', { cacheName: String(cacheName) }); },
+                writable: false,
+                configurable: false,
+            });
+        } catch (e) {}
+        try {
+            Object.defineProperty(window.caches, 'delete', {
+                value: function(cacheName) { reportAndThrow('caches.delete', { cacheName: String(cacheName) }); },
+                writable: false,
+                configurable: false,
+            });
+        } catch (e) {}
+    }
+
+    // Cookies
+    try {
+        Object.defineProperty(document, 'cookie', {
+            get: function() { reportAndThrow('document.cookie (read)', {}); },
+            set: function(value) { reportAndThrow('document.cookie (write)', { value: String(value).slice(0, 64) }); },
+            configurable: false,
+        });
+    } catch (e) {}
+
+    // Wallet extension sniffing
+    ['injectedWeb3', 'polkadot', 'ethereum'].forEach(function(key) {
+        try {
+            Object.defineProperty(window, key, {
+                get: function() { reportAndThrow('window.' + key, {}); },
+                set: function() { reportAndThrow('window.' + key + ' (set)', {}); },
+                configurable: false,
+            });
+        } catch (e) {}
+    });
+
+    // Nested iframes
+    var _origCreateElement = document.createElement.bind(document);
+    document.createElement = function(tag) {
+        if (tag && tag.toLowerCase() === 'iframe') {
+            reportAndThrow('createElement(iframe)', { tag: tag });
+        }
+        return _origCreateElement.apply(this, arguments);
+    };
+    // createElementNS is a separate code path that also produces elements.
+    var _origCreateElementNS = document.createElementNS.bind(document);
+    document.createElementNS = function(ns, tag) {
+        if (tag && tag.toLowerCase() === 'iframe') {
+            reportAndThrow('createElementNS(iframe)', { tag: tag });
+        }
+        return _origCreateElementNS.apply(this, arguments);
+    };
+})();`;
+}
+export const MONITOR_SCRIPT = buildMonitorScript();
+/**
+ * Interactive sandbox script: wraps network APIs with a mutable allowlist.
+ *
+ * - fetch/XHR: checked against an origin allowlist. Unapproved requests
+ *   throw SecurityError and emit SANDBOX_VIOLATION with `disposition: "promptable"`.
+ * - Grant delivery: the host sends `{ type: "sandbox-grant", origin, kind: "network" }`
+ *   over a dedicated MessagePort created by the iframe bridge. The sandbox
+ *   re-validates and adds the origin, then deletes the temporary window handle
+ *   before product code runs.
+ * - Non-network APIs: blocked + reported with `disposition: "always_blocked"`.
+ * - fetch/XHR wrappers use `configurable: false, writable: false` to prevent bypass.
+ * - The allowlist Set is frozen after each mutation to prevent product manipulation.
+ *
+ * Mirrors `generate_interactive_sandbox_script()` from `host-product-view/src/security.rs`.
+ *
+ * @internal Exported for testing only.
+ */
+export function buildInteractiveScript(approvedNetworkOrigins = [], approvedWebSocketOrigins = [], approvedWebRtcServerUrls = []) {
+    const origins = JSON.stringify(normalizeApprovedNetworkOrigins(approvedNetworkOrigins));
+    const webSocketOrigins = JSON.stringify(normalizeApprovedWebSocketOrigins(approvedWebSocketOrigins));
+    const webRtcServerUrls = JSON.stringify(normalizeApprovedWebRtcServerUrls(approvedWebRtcServerUrls));
+    const navigationSetup = buildNavigationGuardBlock("interactive");
+    return `(function() {
+    'use strict';
+
+    // ── Mutable allowlist (frozen after each mutation) ────────────────────
+    var __origins = new Set(${origins});
+    var __webSocketOrigins = new Set(${webSocketOrigins});
+    var __webRtcServerUrls = new Set(${webRtcServerUrls});
+    Object.freeze(__origins);
+    Object.freeze(__webSocketOrigins);
+    Object.freeze(__webRtcServerUrls);
+
+    function __addOrigin(origin) {
+        // Re-validate defense-in-depth: must be https://, no wildcards, no paths
+        if (typeof origin !== 'string') return;
+        if (origin.indexOf('*') !== -1) return;
+        if (!origin.match(/^https:\\/\\/[^\\/\\s?#]+$/)) return;
+        try { new URL(origin); } catch (e) { return; }
+        // Rebuild as a new frozen Set — freeze before assigning so the unfrozen
+        // Set is never observable through __origins.
+        var next = new Set(__origins);
+        next.add(origin);
+        Object.freeze(next);
+        __origins = next;
+    }
+    function __addWebSocketOrigin(origin) {
+        if (typeof origin !== 'string') return;
+        if (origin.indexOf('*') !== -1) return;
+        if (!origin.match(/^wss:\\/\\/[^\\/\\s?#]+$/)) return;
+        try { new URL(origin); } catch (e) { return; }
+        var next = new Set(__webSocketOrigins);
+        next.add(origin);
+        Object.freeze(next);
+        __webSocketOrigins = next;
+    }
+    function __addWebRtcServerUrl(url) {
+        if (typeof url !== 'string') return;
+        var trimmed = url.trim();
+        if (!trimmed.match(/^(stun|turn|turns):/i)) return;
+        if (trimmed.indexOf('?') !== -1 || trimmed.indexOf('#') !== -1 || trimmed.indexOf(' ') !== -1) {
+            return;
+        }
+        var next = new Set(__webRtcServerUrls);
+        next.add(trimmed);
+        Object.freeze(next);
+        __webRtcServerUrls = next;
+    }
+
+    function __isAllowed(input) {
+        try {
+            var url = (typeof input === 'string') ? input
+                : (input && typeof input === 'object' && typeof input.url === 'string') ? input.url
+                : String(input);
+            var parsed = new URL(url, location.href);
+            if (parsed.protocol !== 'https:') return false;
+            return __origins.has(parsed.origin);
+        } catch (e) {
+            return false;
+        }
+    }
+
+    function __extractOrigin(input) {
+        try {
+            var url = (typeof input === 'string') ? input
+                : (input && typeof input === 'object' && typeof input.url === 'string') ? input.url
+                : String(input);
+            var parsed = new URL(url, location.href);
+            return parsed.protocol === 'https:' ? parsed.origin : null;
+        } catch (e) {
+            return null;
+        }
+    }
+    function __extractWebSocketOrigin(input) {
+        try {
+            var parsed = new URL(String(input), location.href);
+            return parsed.protocol === 'wss:' ? parsed.origin : null;
+        } catch (e) {
+            return null;
+        }
+    }
+    function __isAllowedWebSocket(input) {
+        var origin = __extractWebSocketOrigin(input);
+        return origin !== null && __webSocketOrigins.has(origin);
+    }
+    function __normalizeWebRtcServerUrl(input) {
+        if (typeof input !== 'string') return null;
+        var trimmed = input.trim();
+        if (!trimmed.match(/^(stun|turn|turns):/i)) return null;
+        if (trimmed.indexOf('?') !== -1 || trimmed.indexOf('#') !== -1 || trimmed.indexOf(' ') !== -1) {
+            return null;
+        }
+        return trimmed;
+    }
+    function __extractFirstWebRtcServerUrl(config) {
+        if (!config || !config.iceServers) return null;
+        var iceServers = Array.isArray(config.iceServers) ? config.iceServers : [config.iceServers];
+        for (var i = 0; i < iceServers.length; i++) {
+            var entry = iceServers[i];
+            if (!entry) continue;
+            var urls = entry.urls;
+            if (Array.isArray(urls) && urls.length > 0) {
+                return __normalizeWebRtcServerUrl(String(urls[0]));
+            }
+            if (typeof urls === 'string') {
+                return __normalizeWebRtcServerUrl(urls);
+            }
+            if (typeof entry.url === 'string') {
+                return __normalizeWebRtcServerUrl(entry.url);
+            }
+        }
+        return null;
+    }
+    function __isAllowedWebRtc(config) {
+        if (!config || !config.iceServers) return false;
+        var iceServers = Array.isArray(config.iceServers) ? config.iceServers : [config.iceServers];
+        if (iceServers.length === 0) return false;
+        for (var i = 0; i < iceServers.length; i++) {
+            var entry = iceServers[i];
+            if (!entry) return false;
+            var urls = entry.urls;
+            var values = Array.isArray(urls)
+                ? urls
+                : (typeof urls === 'string' ? [urls] : (typeof entry.url === 'string' ? [entry.url] : []));
+            if (values.length === 0) return false;
+            for (var j = 0; j < values.length; j++) {
+                var normalizedUrl = __normalizeWebRtcServerUrl(String(values[j]));
+                if (!normalizedUrl || !__webRtcServerUrls.has(normalizedUrl)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    // ── Violation reporter ───────────────────────────────────────────────
+    function report(api, details, disposition) {
+        var payload = {
+            type: 'SANDBOX_VIOLATION',
+            api: api,
+            details: details || {},
+            disposition: disposition || 'always_blocked',
+            timestamp: Date.now(),
+        };
+        try {
+            var target = (window.parent !== window) ? window.parent : window;
+            target.postMessage(payload, '*');
+        } catch (e) { /* postMessage failure must never suppress the throw below */ }
+        throw new DOMException(
+            api + ' is blocked in sandboxed products', 'SecurityError'
+        );
+    }
+
+    ${navigationSetup}
+
+    // ── Grant listener ───────────────────────────────────────────────────
+    // Consume the dedicated grant port created by buildIframeBridgeScript().
+    // The temporary window handle is deleted before any product code runs so
+    // products cannot self-grant origins.
+    var __grantPort = window.__HOST_SANDBOX_GRANT_PORT__;
+    if (__grantPort) {
+        __grantPort.start();
+        __grantPort.onmessage = function(ev) {
+            if (ev.data && ev.data.type === 'sandbox-grant') {
+                if (ev.data.kind === 'network') {
+                    __addOrigin(ev.data.origin);
+                } else if (ev.data.kind === 'websocket') {
+                    __addWebSocketOrigin(ev.data.origin);
+                } else if (ev.data.kind === 'webrtc') {
+                    __addWebRtcServerUrl(ev.data.url);
+                }
+            }
+        };
+        try { delete window.__HOST_SANDBOX_GRANT_PORT__; } catch (e) {}
+    }
+
+    // ── fetch wrapper (primary interactive gate) ─────────────────────────
+    var _origFetch = window.fetch;
+    if (_origFetch) {
+        Object.defineProperty(window, 'fetch', {
+            value: function(input, init) {
+                if (__isAllowed(input)) {
+                    return _origFetch.apply(this, arguments);
+                }
+                var origin = __extractOrigin(input);
+                var url = (typeof input === 'string') ? input
+                    : (input && typeof input === 'object' && typeof input.url === 'string') ? input.url
+                    : String(input);
+                if (origin) {
+                    // Report origin only — do not leak full URL path/query to parent frame
+                    report('fetch', { origin: origin, method: (init && init.method) || 'GET' }, 'promptable');
+                } else {
+                    report('fetch', {}, 'always_blocked');
+                }
+            },
+            writable: false,
+            configurable: false,
+        });
+    }
+
+    // ── XHR wrapper ──────────────────────────────────────────────────────
+    var _origXhrOpen = XMLHttpRequest.prototype.open;
+    if (_origXhrOpen) {
+        Object.defineProperty(XMLHttpRequest.prototype, 'open', {
+            value: function(method, url) {
+                if (__isAllowed(url)) {
+                    return _origXhrOpen.apply(this, arguments);
+                }
+                var origin = __extractOrigin(url);
+                if (origin) {
+                    // Report origin only — do not leak full URL path/query to parent frame
+                    report('XMLHttpRequest', { method: String(method), origin: origin }, 'promptable');
+                } else {
+                    report('XMLHttpRequest', { method: String(method) }, 'always_blocked');
+                }
+            },
+            writable: false,
+            configurable: false,
+        });
+    }
+
+    // ── Non-network APIs: blocked + reported ─────────────────────────────
+
+    var _origWebSocket = window.WebSocket;
+    if (_origWebSocket) {
+        window.WebSocket = function(url, protocols) {
+            if (__isAllowedWebSocket(url)) {
+                return new _origWebSocket(url, protocols);
+            }
+            var origin = __extractWebSocketOrigin(url);
+            if (origin) {
+                report('WebSocket', { origin: origin }, 'promptable');
+            }
+            report('WebSocket', { url: String(url) }, 'always_blocked');
+        };
+        window.WebSocket.prototype = _origWebSocket.prototype;
+    }
+
+    window.EventSource = function(url) {
+        report('EventSource', { url: String(url) }, 'always_blocked');
+    };
+
+    window.Worker = function(url) {
+        report('Worker', { url: String(url) }, 'always_blocked');
+    };
+
+    var __serviceWorker;
+    try { __serviceWorker = navigator.serviceWorker; } catch (e) { __serviceWorker = null; }
+    if (__serviceWorker) {
+        try {
+            Object.defineProperty(navigator, 'serviceWorker', {
+                get: function() { report('ServiceWorker', {}, 'always_blocked'); },
+                configurable: false,
+            });
+        } catch (e) { /* already non-configurable on this engine — silently accept */ }
+    }
+
+    if (navigator.sendBeacon) {
+        try {
+            Object.defineProperty(navigator, 'sendBeacon', {
+                value: function(url) {
+                    report('sendBeacon', { url: String(url) }, 'always_blocked');
+                },
+                writable: false,
+                configurable: false,
+            });
+        } catch (e) { /* already non-configurable on this engine — silently accept */ }
+    }
+
+    // WebRTC
+    var _origRTCPeerConnection = window.RTCPeerConnection;
+    if (_origRTCPeerConnection) {
+        window.RTCPeerConnection = function(config, constraints) {
+            if (__isAllowedWebRtc(config)) {
+                return new _origRTCPeerConnection(config, constraints);
+            }
+            var server = __extractFirstWebRtcServerUrl(config);
+            if (server) {
+                report('RTCPeerConnection', { server: server }, 'promptable');
+            }
+            report('RTCPeerConnection', {}, 'always_blocked');
+        };
+        window.RTCPeerConnection.prototype = _origRTCPeerConnection.prototype;
+    }
+    window.RTCSessionDescription = function() {
+        report('RTCSessionDescription', {}, 'always_blocked');
+    };
+    window.RTCIceCandidate = function() {
+        report('RTCIceCandidate', {}, 'always_blocked');
+    };
+    window.RTCDataChannel = function() {
+        report('RTCDataChannel', {}, 'always_blocked');
+    };
+
+    // Cross-product communication
+    window.SharedWorker = function(url) {
+        report('SharedWorker', { url: String(url) }, 'always_blocked');
+    };
+    window.BroadcastChannel = function(name) {
+        report('BroadcastChannel', { name: String(name) }, 'always_blocked');
+    };
+
+    // Storage
+    try {
+        Object.defineProperty(window, 'localStorage', {
+            get: function() { report('localStorage', {}, 'always_blocked'); },
+            configurable: false,
+        });
+    } catch (e) { /* already non-configurable — silently accept */ }
+
+    if (window.caches) {
+        try {
+            Object.defineProperty(window.caches, 'open', {
+                value: function(cacheName) {
+                    report('caches.open', { cacheName: String(cacheName) }, 'always_blocked');
+                },
+                writable: false,
+                configurable: false,
+            });
+        } catch (e) {}
+        try {
+            Object.defineProperty(window.caches, 'delete', {
+                value: function(cacheName) {
+                    report('caches.delete', { cacheName: String(cacheName) }, 'always_blocked');
+                },
+                writable: false,
+                configurable: false,
+            });
+        } catch (e) {}
+    }
+
+    // Cookies
+    try {
+        Object.defineProperty(document, 'cookie', {
+            get: function() {
+                report('document.cookie (read)', {}, 'always_blocked');
+            },
+            set: function(value) {
+                report('document.cookie (write)', { value: String(value).slice(0, 64) }, 'always_blocked');
+            },
+            configurable: false,
+        });
+    } catch (e) { /* non-configurable environment — silently accept */ }
+
+    // Wallet extension sniffing
+    ['injectedWeb3', 'polkadot', 'ethereum'].forEach(function(key) {
+        try {
+            Object.defineProperty(window, key, {
+                get: function() { report('window.' + key, {}, 'always_blocked'); },
+                set: function(v) { report('window.' + key + ' (set)', {}, 'always_blocked'); },
+                configurable: false,
+            });
+        } catch (e) { /* already non-configurable — silently accept */ }
+    });
+
+    // Nested iframes
+    var _origCreateElement = document.createElement.bind(document);
+    document.createElement = function(tag) {
+        if (tag && tag.toLowerCase() === 'iframe') {
+            report('createElement(iframe)', { tag: tag }, 'always_blocked');
+        }
+        return _origCreateElement.apply(this, arguments);
+    };
+    // createElementNS is a separate code path that also produces elements.
+    var _origCreateElementNS = document.createElementNS.bind(document);
+    document.createElementNS = function(ns, tag) {
+        if (tag && tag.toLowerCase() === 'iframe') {
+            report('createElementNS(iframe)', { tag: tag }, 'always_blocked');
+        }
+        return _origCreateElementNS.apply(this, arguments);
+    };
+})();`;
+}
+export const INTERACTIVE_SCRIPT = buildInteractiveScript();
+/** Content-Security-Policy for interactive sandbox mode (connect-src https: wss:). */
+export const IFRAME_CSP_INTERACTIVE = "default-src 'none'; " +
+    "script-src 'unsafe-inline' 'wasm-unsafe-eval' data: blob:; " +
+    "style-src 'unsafe-inline'; " +
+    "frame-src 'none'; " +
+    "connect-src https: wss:; " +
+    "img-src blob: data:; " +
+    "font-src 'none'; " +
+    "media-src 'none'; " +
+    "object-src 'none'; " +
+    "base-uri 'none'; " +
+    "form-action 'none'";
+export const IFRAME_CSP_URL_BACKED_INTERACTIVE = "default-src 'none'; " +
+    "script-src 'self' 'unsafe-inline' 'wasm-unsafe-eval' data: blob:; " +
+    "style-src 'self' 'unsafe-inline'; " +
+    "frame-src 'none'; " +
+    "connect-src 'self' https: wss:; " +
+    "img-src 'self' blob: data:; " +
+    "font-src 'self'; " +
+    "media-src 'none'; " +
+    "object-src 'none'; " +
+    "base-uri 'self'; " +
+    "form-action 'none'";
+// ---------------------------------------------------------------------------
+// srcdoc builder
+// ---------------------------------------------------------------------------
+/**
+ * Decode a Uint8Array to a UTF-8 string.
+ * Uses TextDecoder when available (browser / Node 11+), otherwise falls back
+ * to a pure-JS loop so the module remains dependency-free.
+ */
+function decodeUtf8(bytes) {
+    if (typeof TextDecoder !== "undefined") {
+        return new TextDecoder().decode(bytes);
+    }
+    // Fallback: latin-1 safe for ASCII-only HTML; non-ASCII will be garbled
+    // but the CSP will block any active exploits regardless.
+    let out = "";
+    for (let i = 0; i < bytes.length; i++) {
+        out += String.fromCharCode(bytes[i]);
+    }
+    return out;
+}
+function encodeUtf8(source) {
+    if (typeof TextEncoder !== "undefined") {
+        return new TextEncoder().encode(source);
+    }
+    const out = new Uint8Array(source.length);
+    for (let i = 0; i < source.length; i++) {
+        out[i] = source.charCodeAt(i) & 0xff;
+    }
+    return out;
+}
+/**
+ * Escape a raw HTML string for safe embedding as a <script> body.
+ * Replaces `</script>` and `<!--` to prevent premature tag closure.
+ */
+function escapeScriptContent(src) {
+    return src.replace(/<\/script>/gi, "<\\/script>").replace(/<!--/g, "<\\!--");
+}
+/**
+ * Build the full srcdoc string for the sandboxed iframe.
+ *
+ * Preserves the product's original `<head>` structure (meta tags, CSS links,
+ * module scripts, import maps) and injects bridge/lockdown scripts before
+ * any product content. Bundle-local CSS and JS assets referenced by the HTML
+ * are inlined since srcdoc iframes cannot reliably fetch relative paths.
+ *
+ * @internal Exported for testing only — not part of the public API.
+ */
+export function buildSrcdoc(assets, bridgeScript, sandboxScript, extensionInjectScript, approvedNetworkOrigins = [], approvedWebSocketOrigins = [], cspOverride, coreCapabilities) {
+    const bridgeMetadataScript = buildBridgeMetadataScript(extensionInjectScript, "web-srcdoc", coreCapabilities);
+    const sessionBootstrapScript = buildProductViewSessionBootstrapScript();
+    const csp = cspOverride ?? buildIframeCsp(approvedNetworkOrigins, approvedWebSocketOrigins);
+    const baseTag = `<base href="${escapeHtmlAttr(`${SYNTHETIC_PRODUCT_BUNDLE_ORIGIN}/`)}">`;
+    const embeddedAssetScript = buildEmbeddedBundleAssetScript(assets);
+    // Scripts that must run before any product JS.
+    const extensionTag = extensionInjectScript.length > 0
+        ? `<script>${escapeScriptContent(extensionInjectScript)}</script>`
+        : "";
+    const hostScripts = `<meta http-equiv="Content-Security-Policy" content="${csp}">` +
+        baseTag +
+        `<script>${escapeScriptContent(sessionBootstrapScript)}</script>` +
+        `<script>${escapeScriptContent(bridgeScript)}</script>` +
+        `<script>${escapeScriptContent(bridgeMetadataScript)}</script>` +
+        extensionTag +
+        `<script>${escapeScriptContent(sandboxScript)}</script>` +
+        (embeddedAssetScript.length > 0
+            ? `<script>${escapeScriptContent(embeddedAssetScript)}</script>`
+            : "");
+    const indexBytes = assets.get("index.html");
+    if (indexBytes === undefined) {
+        return `<!DOCTYPE html><html><head>${hostScripts}</head><body></body></html>`;
+    }
+    let html = decodeUtf8(indexBytes);
+    // Find which JS/CSS paths are already referenced in the HTML so we
+    // don't double-inline them.
+    const referencedScripts = findReferencedPaths(html, /<script[^>]+src=["']([^"']+)["']/gi);
+    const referencedStyles = findReferencedPaths(html, /<link[^>]+href=["']([^"']+)["']/gi);
+    // Replace bundle-local <link rel="stylesheet" href="X"> with inline <style>.
+    html = inlineLinkedStylesheets(html, assets);
+    // Replace bundle-local <script src="X"> with inline <script> content.
+    // Preserves type="module" and other attributes.
+    html = inlineLinkedScripts(html, assets);
+    // Rewrite remaining bundle-local HTML embeds (images, icons, posters, etc.)
+    // to self-contained data URLs so the guest never falls back to the host origin.
+    html = rewriteBundleLocalHtmlEmbeds(html, assets);
+    // Strip bundle-local modulepreload hints. Once scripts are inlined into the
+    // srcdoc document, these preloads no longer provide value and will otherwise
+    // attempt blocked network fetches from the opaque iframe origin.
+    html = stripBundleModulePreloads(html, assets);
+    // Inject host scripts at the start of <head> (or create <head> if missing).
+    html = injectIntoHead(html, hostScripts);
+    const bundleImportMap = buildBundleImportMap(assets, referencedScripts);
+    if (bundleImportMap.length > 0) {
+        html = injectBeforeHeadClose(html, bundleImportMap);
+    }
+    // Inline unreferenced CSS assets at the end of <head>.
+    const extraStyles = [];
+    for (const [path, bytes] of assets) {
+        if (!path.endsWith(".css"))
+            continue;
+        if (referencedStyles.has(path))
+            continue;
+        const src = rewriteCssWithEmbeddedAssets(decodeUtf8(bytes), assets);
+        extraStyles.push(`<style>${escapeStyleContent(src)}</style>`);
+    }
+    if (extraStyles.length > 0) {
+        html = injectBeforeHeadClose(html, extraStyles.join(""));
+    }
+    // Ensure DOCTYPE exists.
+    if (!/<!DOCTYPE/i.test(html)) {
+        html = "<!DOCTYPE html>" + html;
+    }
+    return html;
+}
+/**
+ * Build a URL-backed product document.
+ *
+ * Unlike `buildSrcdoc()`, this path preserves the bundle's file structure and
+ * expects the host to serve the returned assets from `routeBasePath`.
+ */
+export function buildUrlBackedDocument(assets, bridgeScript, sandboxScript, extensionInjectScript, routeBasePath, approvedNetworkOrigins = [], approvedWebSocketOrigins = [], cspOverride, coreCapabilities) {
+    const bridgeMetadataScript = buildBridgeMetadataScript(extensionInjectScript, "web-relay", coreCapabilities);
+    const sessionBootstrapScript = buildProductViewSessionBootstrapScript();
+    const csp = cspOverride ?? buildUrlBackedIframeCsp(approvedNetworkOrigins, approvedWebSocketOrigins);
+    const normalizedBase = normalizeRouteBasePath(routeBasePath);
+    const baseTag = `<base href="${escapeHtmlAttr(normalizedBase)}">`;
+    const extensionTag = extensionInjectScript.length > 0
+        ? `<script>${escapeScriptContent(extensionInjectScript)}</script>`
+        : "";
+    const hostScripts = `<meta http-equiv="Content-Security-Policy" content="${csp}">` +
+        baseTag +
+        `<script>${escapeScriptContent(sessionBootstrapScript)}</script>` +
+        `<script>${escapeScriptContent(bridgeScript)}</script>` +
+        `<script>${escapeScriptContent(bridgeMetadataScript)}</script>` +
+        extensionTag +
+        `<script>${escapeScriptContent(sandboxScript)}</script>`;
+    const indexBytes = assets.get("index.html");
+    if (indexBytes === undefined) {
+        return `<!DOCTYPE html><html><head>${hostScripts}</head><body></body></html>`;
+    }
+    let html = decodeUtf8(indexBytes);
+    html = rewriteBundleLocalHtmlPaths(html, assets, normalizedBase);
+    html = rewriteBundleLocalTextPaths(html, assets, normalizedBase);
+    html = injectIntoHead(html, hostScripts);
+    if (!/<!DOCTYPE/i.test(html)) {
+        html = "<!DOCTYPE html>" + html;
+    }
+    return html;
+}
+function normalizeRouteBasePath(routeBasePath) {
+    const trimmed = routeBasePath.trim();
+    if (trimmed === "" || trimmed === "/") {
+        return "/";
+    }
+    const withLeadingSlash = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+    return withLeadingSlash.endsWith("/") ? withLeadingSlash : `${withLeadingSlash}/`;
+}
+function resolveProductViewSessionToken(frameUrl) {
+    try {
+        const parsed = new URL(frameUrl, window.location.href);
+        const directToken = parsed.searchParams.get(HOST_PRODUCT_VIEW_SESSION_QUERY_KEY);
+        if (directToken != null && directToken !== "") {
+            return directToken;
+        }
+        const nestedProductUrl = parsed.searchParams.get("productUrl");
+        if (nestedProductUrl != null && nestedProductUrl !== "") {
+            const nested = new URL(nestedProductUrl, parsed);
+            const nestedToken = nested.searchParams.get(HOST_PRODUCT_VIEW_SESSION_QUERY_KEY);
+            if (nestedToken != null && nestedToken !== "") {
+                return nestedToken;
+            }
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+function appendProductViewSessionToken(frameUrl, sessionToken) {
+    const parsed = new URL(frameUrl, window.location.href);
+    const nestedProductUrl = parsed.searchParams.get("productUrl");
+    if (nestedProductUrl != null && nestedProductUrl !== "") {
+        const nested = new URL(nestedProductUrl, parsed);
+        nested.searchParams.set(HOST_PRODUCT_VIEW_SESSION_QUERY_KEY, sessionToken);
+        parsed.searchParams.set("productUrl", nested.toString());
+        return parsed.toString();
+    }
+    parsed.searchParams.set(HOST_PRODUCT_VIEW_SESSION_QUERY_KEY, sessionToken);
+    return parsed.toString();
+}
+function rewriteBundleLocalHtmlPaths(html, assets, routeBasePath) {
+    return html.replace(/\b(src|href|poster)\s*=\s*(["'])([^"']+)\2/gi, (fullMatch, attrName, quote, rawValue) => {
+        if (!rawValue.startsWith("/")) {
+            return fullMatch;
+        }
+        const normalized = normalizeAssetPath(rawValue);
+        if (!assets.has(normalized)) {
+            return fullMatch;
+        }
+        return `${attrName}=${quote}${routeBasePath}${normalized}${quote}`;
+    });
+}
+function rewriteBundleLocalCssPaths(css, assets, routeBasePath) {
+    const rewrittenUrls = css.replace(/url\(\s*(["']?)(\/[^"')]+)\1\s*\)/gi, (fullMatch, quote, rawValue) => {
+        const normalized = normalizeAssetPath(rawValue);
+        if (!assets.has(normalized)) {
+            return fullMatch;
+        }
+        return `url(${quote}${routeBasePath}${normalized}${quote})`;
+    });
+    return rewrittenUrls.replace(/(@import\s+["'])(\/[^"']+)(["'])/gi, (fullMatch, prefix, rawValue, suffix) => {
+        const normalized = normalizeAssetPath(rawValue);
+        if (!assets.has(normalized)) {
+            return fullMatch;
+        }
+        return `${prefix}${routeBasePath}${normalized}${suffix}`;
+    });
+}
+function isBundleLocalAbsolutePath(path, assets) {
+    if (path === "") {
+        return false;
+    }
+    if (assets.has(path)) {
+        return true;
+    }
+    const directoryPrefix = path.endsWith("/") ? path : `${path}/`;
+    for (const assetPath of assets.keys()) {
+        if (assetPath.startsWith(directoryPrefix)) {
+            return true;
+        }
+    }
+    return false;
+}
+function rewriteBundleLocalTextPaths(source, assets, routeBasePath) {
+    const rewriteRawPath = (rawValue) => {
+        if (rawValue.startsWith("//")) {
+            return null;
+        }
+        const normalized = normalizeAssetPath(rawValue);
+        if (!isBundleLocalAbsolutePath(normalized, assets)) {
+            return null;
+        }
+        const suffixMatch = rawValue.match(/[?#].*$/);
+        const suffix = suffixMatch?.[0] ?? "";
+        const needsTrailingSlash = rawValue.endsWith("/") && !suffix && !normalized.endsWith("/");
+        return `${routeBasePath}${normalized}${needsTrailingSlash ? "/" : ""}${suffix}`;
+    };
+    const rewriteDirectQuotes = source.replace(/(["'])((?![a-zA-Z][a-zA-Z0-9+.-]*:|\/\/|\.{1,2}\/|#)[^"'\\]+)\1/g, (fullMatch, quote, rawValue) => {
+        const nextPath = rewriteRawPath(rawValue);
+        return nextPath == null ? fullMatch : `${quote}${nextPath}${quote}`;
+    });
+    return rewriteDirectQuotes.replace(/(\\["'])((?![a-zA-Z][a-zA-Z0-9+.-]*:|\/\/|\.{1,2}\/|#)[^"'\\]+)(\\["'])/g, (fullMatch, prefix, rawValue, suffix) => {
+        const nextPath = rewriteRawPath(rawValue);
+        return nextPath == null ? fullMatch : `${prefix}${nextPath}${suffix}`;
+    });
+}
+function rewriteBundleLocalHtmlEmbeds(html, assets) {
+    return html.replace(/\b(src|href|poster)\s*=\s*(["'])([^"']+)\2/gi, (fullMatch, attrName, quote, rawValue) => {
+        const normalized = normalizeAssetPath(rawValue);
+        if (normalized === "") {
+            return fullMatch;
+        }
+        const bytes = assets.get(normalized);
+        if (bytes === undefined) {
+            return fullMatch;
+        }
+        if (normalized.endsWith(".js") || normalized.endsWith(".css")) {
+            return fullMatch;
+        }
+        return `${attrName}=${quote}${bytesToDataUrl(bytes, guessMimeType(normalized))}${quote}`;
+    });
+}
+function rewriteCssWithEmbeddedAssets(css, assets) {
+    const rewrittenUrls = css.replace(/url\(\s*(["']?)([^"')]+)\1\s*\)/gi, (fullMatch, quote, rawValue) => {
+        const normalized = normalizeAssetPath(rawValue);
+        const bytes = assets.get(normalized);
+        if (bytes === undefined) {
+            return fullMatch;
+        }
+        return `url(${quote}${bytesToDataUrl(bytes, guessMimeType(normalized))}${quote})`;
+    });
+    return rewrittenUrls.replace(/(@import\s+["'])([^"']+)(["'])/gi, (fullMatch, prefix, rawValue, suffix) => {
+        const normalized = normalizeAssetPath(rawValue);
+        const bytes = assets.get(normalized);
+        if (bytes === undefined) {
+            return fullMatch;
+        }
+        return `${prefix}${bytesToDataUrl(bytes, guessMimeType(normalized))}${suffix}`;
+    });
+}
+/** Find all paths referenced by a regex with a capture group for the path. */
+function findReferencedPaths(html, regex) {
+    const paths = new Set();
+    let match;
+    while ((match = regex.exec(html)) !== null) {
+        const path = normalizeAssetPath(match[1]);
+        paths.add(path);
+    }
+    return paths;
+}
+function normalizeAssetPath(path) {
+    const stripped = path
+        .replace(/^[./]+/, "")
+        .replace(/^\//, "")
+        .replace(/[?#].*$/, "");
+    try {
+        return decodeURIComponent(stripped);
+    }
+    catch {
+        return stripped;
+    }
+}
+/** Replace <link rel="stylesheet" href="X"> with <style>content</style> for bundle-local assets. */
+function inlineLinkedStylesheets(html, assets) {
+    return html.replace(/<link\b([^>]*)\/?>/gi, (fullMatch, attrs) => {
+        const rel = readHtmlAttr(attrs, "rel");
+        if (rel?.toLowerCase() !== "stylesheet") {
+            return fullMatch;
+        }
+        const href = readHtmlAttr(attrs, "href");
+        if (href == null) {
+            return fullMatch;
+        }
+        const path = normalizeAssetPath(href);
+        const bytes = assets.get(path);
+        if (bytes === undefined)
+            return fullMatch; // external — keep as-is
+        return `<style>${escapeStyleContent(rewriteCssWithEmbeddedAssets(decodeUtf8(bytes), assets))}</style>`;
+    });
+}
+/** Replace <script src="X"> with inline <script>content</script> for bundle-local assets.
+ *
+ * Preserves the original script type (classic, module, nomodule). Does NOT
+ * inject type="module" on classic scripts — that would change execution
+ * timing, scope, and strict-mode behavior.
+ */
+function inlineLinkedScripts(html, assets) {
+    return html.replace(/<script\b([^>]*)>\s*<\/script>/gi, (fullMatch, attrs) => {
+        const src = readHtmlAttr(attrs, "src");
+        if (src == null) {
+            return fullMatch;
+        }
+        const path = normalizeAssetPath(src);
+        const bytes = assets.get(path);
+        if (bytes === undefined)
+            return fullMatch; // external — keep as-is
+        const nextAttrs = stripHtmlAttr(attrs, "src").trim();
+        return `<script${nextAttrs ? " " + nextAttrs : ""}>${escapeScriptContent(decodeJavascriptAsset(path, bytes, assets))}</script>`;
+    });
+}
+function stripBundleModulePreloads(html, assets) {
+    return html.replace(/<link\b([^>]*)\/?>/gi, (fullMatch, attrs) => {
+        const rel = readHtmlAttr(attrs, "rel");
+        if (rel?.toLowerCase() !== "modulepreload") {
+            return fullMatch;
+        }
+        const href = readHtmlAttr(attrs, "href");
+        if (href == null) {
+            return fullMatch;
+        }
+        const path = normalizeAssetPath(href);
+        return assets.has(path) ? "" : fullMatch;
+    });
+}
+function buildBundleImportMap(assets, _referencedScripts) {
+    const imports = {};
+    const moduleUrlCache = new Map();
+    for (const [path, bytes] of assets) {
+        if (!path.endsWith(".js"))
+            continue;
+        const specifiers = bundleImportSpecifiers(path);
+        const dataUrl = buildJavascriptModuleDataUrl(path, assets, moduleUrlCache);
+        for (const specifier of specifiers) {
+            imports[specifier] = dataUrl;
+        }
+    }
+    if (Object.keys(imports).length === 0) {
+        return "";
+    }
+    return `<script type="importmap">${JSON.stringify({ imports })}</script>`;
+}
+function bundleImportSpecifiers(path) {
+    const normalized = normalizeAssetPath(path);
+    const parts = normalized.split("/");
+    const basename = parts[parts.length - 1] ?? normalized;
+    return Array.from(new Set([
+        normalized,
+        `./${normalized}`,
+        `/${normalized}`,
+        basename,
+        `./${basename}`,
+        `/${basename}`,
+    ]));
+}
+function stringToDataUrl(source, mimeType) {
+    const bytes = encodeUtf8(source);
+    return bytesToDataUrl(bytes, mimeType);
+}
+function bytesToDataUrl(bytes, mimeType) {
+    let binary = "";
+    for (let i = 0; i < bytes.length; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    if (typeof btoa === "function") {
+        return `data:${mimeType};base64,${btoa(binary)}`;
+    }
+    const bufferCtor = globalThis.Buffer;
+    if (bufferCtor != null) {
+        return `data:${mimeType};base64,${bufferCtor.from(bytes).toString("base64")}`;
+    }
+    throw new Error("base64 encoding unavailable");
+}
+function decodeJavascriptAsset(path, bytes, assets) {
+    const source = decodeUtf8(bytes);
+    const syntheticUrl = `${SYNTHETIC_PRODUCT_BUNDLE_ORIGIN}/${normalizeAssetPath(path)}`;
+    const rewrittenImports = rewriteJavascriptModuleSpecifiers(source, path, assets);
+    return rewrittenImports.replace(/\bimport\.meta\.url\b/g, JSON.stringify(syntheticUrl));
+}
+function buildJavascriptModuleDataUrl(path, assets, cache, visiting = new Set()) {
+    const normalizedPath = normalizeAssetPath(path);
+    const cached = cache.get(normalizedPath);
+    if (cached != null) {
+        return cached;
+    }
+    const bytes = assets.get(normalizedPath);
+    if (bytes === undefined) {
+        throw new Error(`[product-view] missing JS asset '${normalizedPath}'`);
+    }
+    if (visiting.has(normalizedPath)) {
+        return `${SYNTHETIC_PRODUCT_BUNDLE_ORIGIN}/${normalizedPath}`;
+    }
+    visiting.add(normalizedPath);
+    const source = decodeUtf8(bytes);
+    const rewrittenImports = rewriteJavascriptModuleSpecifiers(source, normalizedPath, assets, cache, visiting);
+    const syntheticUrl = `${SYNTHETIC_PRODUCT_BUNDLE_ORIGIN}/${normalizedPath}`;
+    const rewrittenSource = rewrittenImports.replace(/\bimport\.meta\.url\b/g, JSON.stringify(syntheticUrl));
+    const dataUrl = stringToDataUrl(rewrittenSource, "text/javascript");
+    cache.set(normalizedPath, dataUrl);
+    visiting.delete(normalizedPath);
+    return dataUrl;
+}
+function rewriteJavascriptModuleSpecifiers(source, currentPath, assets, cache = new Map(), visiting = new Set()) {
+    const rewriteSpecifier = (rawSpecifier) => {
+        const resolvedPath = resolveJavascriptAssetPath(currentPath, rawSpecifier, assets);
+        if (resolvedPath == null) {
+            return rawSpecifier;
+        }
+        if (resolvedPath.endsWith(".js") || resolvedPath.endsWith(".mjs")) {
+            return buildJavascriptModuleDataUrl(resolvedPath, assets, cache, visiting);
+        }
+        const bytes = assets.get(resolvedPath);
+        if (bytes === undefined) {
+            return rawSpecifier;
+        }
+        return bytesToDataUrl(bytes, guessMimeType(resolvedPath));
+    };
+    const replaceModuleSpecifier = (code, pattern) => code.replace(pattern, (fullMatch, prefix, specifier, suffix) => {
+        const nextSpecifier = rewriteSpecifier(specifier);
+        if (nextSpecifier === specifier) {
+            return fullMatch;
+        }
+        return `${prefix}${nextSpecifier}${suffix}`;
+    });
+    let next = source;
+    next = replaceModuleSpecifier(next, /(\bimport\s*\(\s*["'])([^"']+)(["']\s*\))/g);
+    next = replaceModuleSpecifier(next, /(\bfrom\s*["'])([^"']+)(["'])/g);
+    next = replaceModuleSpecifier(next, /(\bimport\s*["'])([^"']+)(["'])/g);
+    return next;
+}
+function resolveJavascriptAssetPath(currentPath, rawSpecifier, assets) {
+    if (rawSpecifier.startsWith("data:") ||
+        rawSpecifier.startsWith("blob:") ||
+        rawSpecifier.startsWith("http:") ||
+        rawSpecifier.startsWith("https:")) {
+        return null;
+    }
+    const currentDir = currentPath.includes("/")
+        ? currentPath.slice(0, currentPath.lastIndexOf("/") + 1)
+        : "";
+    let resolvedPath;
+    if (rawSpecifier.startsWith("/")) {
+        resolvedPath = normalizeAssetPath(rawSpecifier);
+    }
+    else {
+        resolvedPath = normalizeAssetPath(new URL(rawSpecifier, `${SYNTHETIC_PRODUCT_BUNDLE_ORIGIN}/${currentDir}`).pathname);
+    }
+    return assets.has(resolvedPath) ? resolvedPath : null;
+}
+function readHtmlAttr(attrs, name) {
+    const pattern = new RegExp(`(?:^|\\s)${name}\\s*=\\s*(?:\"([^\"]*)\"|'([^']*)'|([^\\s>]+))`, "i");
+    const match = attrs.match(pattern);
+    return match == null ? null : (match[1] ?? match[2] ?? match[3] ?? null);
+}
+function stripHtmlAttr(attrs, name) {
+    const pattern = new RegExp(`(^|\\s)${name}\\s*=\\s*(?:\"[^\"]*\"|'[^']*'|[^\\s>]+)`, "ig");
+    return attrs.replace(pattern, "$1").replace(/\s+/g, " ").trim();
+}
+/** Escape CSS content that could break out of a <style> block. */
+function escapeStyleContent(src) {
+    return src.replace(/<\/style>/gi, "<\\/style>");
+}
+function escapeHtmlAttr(value) {
+    return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+}
+function guessMimeType(path) {
+    const lower = normalizeAssetPath(path).toLowerCase();
+    if (lower.endsWith(".html") || lower.endsWith(".htm"))
+        return "text/html";
+    if (lower.endsWith(".css"))
+        return "text/css";
+    if (lower.endsWith(".js") || lower.endsWith(".mjs"))
+        return "text/javascript";
+    if (lower.endsWith(".json"))
+        return "application/json";
+    if (lower.endsWith(".wasm"))
+        return "application/wasm";
+    if (lower.endsWith(".svg"))
+        return "image/svg+xml";
+    if (lower.endsWith(".png"))
+        return "image/png";
+    if (lower.endsWith(".jpg") || lower.endsWith(".jpeg"))
+        return "image/jpeg";
+    if (lower.endsWith(".gif"))
+        return "image/gif";
+    if (lower.endsWith(".webp"))
+        return "image/webp";
+    if (lower.endsWith(".woff"))
+        return "font/woff";
+    if (lower.endsWith(".woff2"))
+        return "font/woff2";
+    if (lower.endsWith(".txt"))
+        return "text/plain";
+    return "application/octet-stream";
+}
+function buildEmbeddedBundleAssetScript(assets) {
+    const bundleAssets = {};
+    for (const [path, bytes] of assets) {
+        if (path === "index.html") {
+            continue;
+        }
+        bundleAssets[`${SYNTHETIC_PRODUCT_BUNDLE_ORIGIN}/${normalizeAssetPath(path)}`] = bytesToDataUrl(bytes, guessMimeType(path));
+    }
+    if (Object.keys(bundleAssets).length === 0) {
+        return "";
+    }
+    return `(function() {
+    'use strict';
+    var bundleAssets = ${JSON.stringify(bundleAssets)};
+    function resolve(input) {
+      try {
+        var candidate = (typeof input === 'string') ? input : (input && input.url ? input.url : String(input));
+        return new URL(candidate, document.baseURI || location.href).toString();
+      } catch (e) {
+        return null;
+      }
+    }
+    function bundleDataUrlFor(input) {
+      var resolved = resolve(input);
+      if (resolved === null) {
+        return null;
+      }
+      return Object.prototype.hasOwnProperty.call(bundleAssets, resolved) ? bundleAssets[resolved] : null;
+    }
+    window.__HOST_PRODUCT_BUNDLE__ = {
+      resolve: resolve,
+      assetFor: bundleDataUrlFor,
+    };
+    var _origFetch = window.fetch;
+    if (_origFetch) {
+      window.fetch = function(input, init) {
+        var dataUrl = bundleDataUrlFor(input);
+        if (dataUrl !== null) {
+          return _origFetch.call(this, dataUrl);
+        }
+        return _origFetch.apply(this, arguments);
+      };
+    }
+    if (window.XMLHttpRequest && window.XMLHttpRequest.prototype && window.XMLHttpRequest.prototype.open) {
+      var _origXhrOpen = window.XMLHttpRequest.prototype.open;
+      window.XMLHttpRequest.prototype.open = function(method, url) {
+        var dataUrl = bundleDataUrlFor(url);
+        var nextUrl = dataUrl !== null ? dataUrl : url;
+        return _origXhrOpen.apply(this, [method, nextUrl].concat(Array.prototype.slice.call(arguments, 2)));
+      };
+    }
+  })();`;
+}
+/** Inject HTML content right after the opening <head> tag. */
+function injectIntoHead(html, content) {
+    const headMatch = html.match(/<head[^>]*>/i);
+    if (headMatch !== null) {
+        const idx = headMatch.index + headMatch[0].length;
+        return html.slice(0, idx) + content + html.slice(idx);
+    }
+    // No <head> — wrap in one.
+    const htmlMatch = html.match(/<html[^>]*>/i);
+    if (htmlMatch !== null) {
+        const idx = htmlMatch.index + htmlMatch[0].length;
+        return html.slice(0, idx) + `<head>${content}</head>` + html.slice(idx);
+    }
+    return `<head>${content}</head>` + html;
+}
+/** Inject HTML content just before </head>. */
+function injectBeforeHeadClose(html, content) {
+    const idx = html.search(/<\/head>/i);
+    if (idx === -1)
+        return html;
+    return html.slice(0, idx) + content + html.slice(idx);
+}
+/** Inject HTML content just before </body>. */
+function injectBeforeBodyClose(html, content) {
+    const idx = html.search(/<\/body>/i);
+    if (idx === -1)
+        return html + content;
+    return html.slice(0, idx) + content + html.slice(idx);
+}
+function resolveProductViewScripts(sdk, options) {
+    const { approvedNetworkOrigins = [], approvedWebSocketOrigins = [], approvedWebRtcServerUrls = [], enableViolationMonitor, enableInteractiveSandbox, traceContext, bridgeAdapter, } = options;
+    if (enableViolationMonitor === true && enableInteractiveSandbox === true) {
+        throw new Error("[product-view] enableViolationMonitor and enableInteractiveSandbox are mutually exclusive");
+    }
+    const iframeBridgeScript = buildIframeBridgeScript(enableInteractiveSandbox === true);
+    let sandboxScript;
+    let cspOverride;
+    if (enableInteractiveSandbox === true) {
+        sandboxScript = buildInteractiveScript(approvedNetworkOrigins, approvedWebSocketOrigins, approvedWebRtcServerUrls);
+        cspOverride = IFRAME_CSP_INTERACTIVE;
+    }
+    else if (enableViolationMonitor === true) {
+        sandboxScript = buildMonitorScript(approvedNetworkOrigins, approvedWebSocketOrigins, approvedWebRtcServerUrls);
+    }
+    else {
+        sandboxScript = buildLockdownScript(approvedNetworkOrigins, approvedWebSocketOrigins, approvedWebRtcServerUrls);
+    }
+    const extensionInjectScript = sdk.extensionInjectScript();
+    const traceContextScript = traceContext ? buildTraceContextScript(traceContext) : "";
+    // Only inject the stable bridge script when a bridge adapter is provided.
+    // Without an adapter, bridge calls would never settle — better to not
+    // expose the methods at all.
+    const stableBridgeScript = bridgeAdapter !== undefined ? buildStableBridgeScript() : "";
+    const coreCapabilities = {
+        storage: bridgeAdapter?.storage !== undefined,
+        statements: bridgeAdapter?.statements !== undefined,
+        identity: bridgeAdapter?.identity !== undefined,
+    };
+    const combinedBridgeScript = [traceContextScript, iframeBridgeScript, stableBridgeScript]
+        .filter(Boolean)
+        .join("\n");
+    return {
+        combinedBridgeScript,
+        sandboxScript,
+        cspOverride,
+        extensionInjectScript,
+        coreCapabilities,
+    };
+}
+// ---------------------------------------------------------------------------
+// Stable bridge call helpers
+// ---------------------------------------------------------------------------
+/**
+ * Dispatch a `host-bridge-call` from the guest to the host adapter and post
+ * the reply back to the iframe.
+ */
+function handleBridgeCall(adapter, method, args, callId, iframe, targetOrigin, sessionToken) {
+    const reply = (result, error, errorCode) => {
+        const payload = error !== undefined
+            ? sessionToken !== undefined
+                ? { type: "host-bridge-reply", callId, error, errorCode, session: sessionToken }
+                : { type: "host-bridge-reply", callId, error, errorCode }
+            : sessionToken !== undefined
+                ? { type: "host-bridge-reply", callId, result: result ?? null, session: sessionToken }
+                : { type: "host-bridge-reply", callId, result: result ?? null };
+        iframe.contentWindow?.postMessage(payload, targetOrigin);
+    };
+    if (adapter === undefined) {
+        reply(undefined, "Bridge adapter not configured", "ERR_HOST_RUNTIME_UNAVAILABLE");
+        return;
+    }
+    const call = resolveBridgeMethod(adapter, method, args);
+    if (call === null) {
+        reply(undefined, `Unsupported method: ${method}`, "ERR_UNSUPPORTED_CAPABILITY");
+        return;
+    }
+    call
+        .then((result) => reply(result))
+        .catch((err) => {
+        const msg = err instanceof Error ? err.message : String(err);
+        const code = err !== null && typeof err === "object" && "code" in err && typeof err.code === "string"
+            ? err.code
+            : "ERR_HOST_RUNTIME_UNAVAILABLE";
+        reply(undefined, msg, code);
+    });
+}
+/**
+ * Map a bridge method name to a promise from the adapter.
+ *
+ * Returns `null` when the method is unknown or the adapter does not implement
+ * it, which causes the caller to reject with `ERR_UNSUPPORTED_CAPABILITY`.
+ */
+function invalidArgError(method, expected) {
+    return Promise.reject(Object.assign(new Error(`${method} requires ${expected} argument(s)`), {
+        code: "ERR_INVALID_ARGUMENT",
+    }));
+}
+function resolveBridgeMethod(adapter, method, args) {
+    switch (method) {
+        case "getAddress":
+            return adapter.getAddress?.() ?? null;
+        case "storage.get":
+            if (args.length < 1 || typeof args[0] !== "string")
+                return invalidArgError(method, 1);
+            return adapter.storage?.get(args[0]) ?? null;
+        case "storage.set":
+            if (args.length < 2 || typeof args[0] !== "string" || typeof args[1] !== "string")
+                return invalidArgError(method, 2);
+            return adapter.storage?.set(args[0], args[1]).then(() => true) ?? null;
+        case "storage.remove":
+            if (args.length < 1 || typeof args[0] !== "string")
+                return invalidArgError(method, 1);
+            return adapter.storage?.remove(args[0]).then(() => true) ?? null;
+        case "statements.subscribe":
+            if (args.length < 1 || typeof args[0] !== "string")
+                return invalidArgError(method, 1);
+            return adapter.statements?.subscribe(args[0]) ?? null;
+        case "statements.write":
+            if (args.length < 2 || typeof args[0] !== "string" || typeof args[1] !== "string")
+                return invalidArgError(method, 2);
+            return adapter.statements?.write(args[0], args[1]) ?? null;
+        case "statements.status":
+            return adapter.statements?.status() ?? null;
+        case "identity.resolveUsername":
+            if (args.length < 1 || typeof args[0] !== "string")
+                return invalidArgError(method, 1);
+            return adapter.identity?.resolveUsername(args[0]) ?? null;
+        default:
+            return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// Main export
+// ---------------------------------------------------------------------------
+export function prepareProductViewAssets(options) {
+    const { assets, sdk, approvedNetworkOrigins = [], approvedWebSocketOrigins = [], approvedWebRtcServerUrls = [], enableViolationMonitor, enableInteractiveSandbox, traceContext, routeBasePath, bridgeAdapter, } = options;
+    const scripts = resolveProductViewScripts(sdk, {
+        approvedNetworkOrigins,
+        approvedWebSocketOrigins,
+        approvedWebRtcServerUrls,
+        enableViolationMonitor,
+        enableInteractiveSandbox,
+        traceContext,
+        bridgeAdapter,
+    });
+    const urlBackedCspOverride = enableInteractiveSandbox === true ? IFRAME_CSP_URL_BACKED_INTERACTIVE : undefined;
+    const preparedAssets = new Map(assets);
+    const preparedHtml = buildUrlBackedDocument(assets, scripts.combinedBridgeScript, scripts.sandboxScript, scripts.extensionInjectScript, routeBasePath, approvedNetworkOrigins, approvedWebSocketOrigins, urlBackedCspOverride, scripts.coreCapabilities);
+    preparedAssets.set("index.html", encodeUtf8(preparedHtml));
+    const normalizedBase = normalizeRouteBasePath(routeBasePath);
+    for (const [path, bytes] of preparedAssets) {
+        if (path.endsWith(".css")) {
+            preparedAssets.set(path, encodeUtf8(rewriteBundleLocalCssPaths(decodeUtf8(bytes), preparedAssets, normalizedBase)));
+            continue;
+        }
+        if (path.endsWith(".js") ||
+            path.endsWith(".mjs") ||
+            path.endsWith(".json") ||
+            path.endsWith(".txt")) {
+            preparedAssets.set(path, encodeUtf8(rewriteBundleLocalTextPaths(decodeUtf8(bytes), preparedAssets, normalizedBase)));
+        }
+    }
+    return preparedAssets;
+}
+export function mountProductView(options) {
+    const { container, productId, assets, sdk, delegate, enableViolationMonitor, enableInteractiveSandbox, approvedNetworkOrigins = [], approvedWebSocketOrigins = [], approvedWebRtcServerUrls = [], traceContext, analyticsRouter, bridgeAdapter, } = options;
+    // Determine whether violation routing is active.
+    const violationRoutingActive = enableViolationMonitor === true || enableInteractiveSandbox === true;
+    // Notify delegate: entering loading state.
+    delegate.onLoadStateChanged?.("loading");
+    const scripts = resolveProductViewScripts(sdk, {
+        approvedNetworkOrigins,
+        approvedWebSocketOrigins,
+        approvedWebRtcServerUrls,
+        enableViolationMonitor,
+        enableInteractiveSandbox,
+        traceContext,
+        bridgeAdapter,
+    });
+    const srcdoc = buildSrcdoc(assets, scripts.combinedBridgeScript, scripts.sandboxScript, scripts.extensionInjectScript, approvedNetworkOrigins, approvedWebSocketOrigins, scripts.cspOverride, scripts.coreCapabilities);
+    // Create the iframe element.
+    const iframe = document.createElement("iframe");
+    iframe.setAttribute("sandbox", IFRAME_SANDBOX_ATTR);
+    iframe.style.width = "100%";
+    iframe.style.height = "100%";
+    iframe.style.border = "none";
+    // Message handler: relay messages from the iframe to the delegate.
+    let sandboxGrantPort = null;
+    let livenessTimeoutId = null;
+    const clearLivenessWatchdog = () => {
+        if (livenessTimeoutId !== null) {
+            window.clearTimeout(livenessTimeoutId);
+            livenessTimeoutId = null;
+        }
+    };
+    const refreshLivenessWatchdog = () => {
+        clearLivenessWatchdog();
+        livenessTimeoutId = window.setTimeout(() => {
+            handleUnexpectedNavigation();
+        }, 1500);
+    };
+    const onMessage = (event) => {
+        if (unexpectedNavigationHandled)
+            return;
+        // Only accept messages from our iframe's contentWindow.
+        if (event.source !== iframe.contentWindow)
+            return;
+        const msg = event.data;
+        if (msg === null || typeof msg !== "object")
+            return;
+        if (msg["type"] === "hostapi-heartbeat") {
+            refreshLivenessWatchdog();
+            return;
+        }
+        // Only accept the grant port in interactive sandbox mode.  In monitor or
+        // lockdown modes the iframe bridge never sends this message, but an
+        // untrusted product could try to spoof it to gain a persistent postMessage
+        // channel.  Silently drop the message in non-interactive modes.
+        if (msg["type"] === "hostapi-grant-port") {
+            if (enableInteractiveSandbox === true) {
+                const port = event.ports?.[0];
+                if (port instanceof MessagePort) {
+                    sandboxGrantPort?.close();
+                    sandboxGrantPort = port;
+                    sandboxGrantPort.start();
+                }
+            }
+            return;
+        }
+        if (msg["type"] === "SANDBOX_VIOLATION" && violationRoutingActive) {
+            const now = Date.now();
+            const violation = {
+                api: typeof msg["api"] === "string" ? msg["api"] : String(msg["api"] ?? "unknown"),
+                details: msg["details"] !== null && typeof msg["details"] === "object"
+                    ? msg["details"]
+                    : {},
+                timestamp: typeof msg["timestamp"] === "number" ? msg["timestamp"] : now,
+                hostTimestamp: now,
+                disposition: msg["disposition"] === "promptable" || msg["disposition"] === "always_blocked"
+                    ? msg["disposition"]
+                    : undefined,
+            };
+            try {
+                delegate.onSandboxViolation?.(violation, productId);
+            }
+            catch (err) {
+                delegate.onError?.(err instanceof Error ? err : new Error(String(err)));
+            }
+            return;
+        }
+        if (isProductAnalyticsMessage(msg) && traceContext?.sampled === true) {
+            const analyticsEvent = msg.event;
+            try {
+                analyticsRouter?.dispatch(productId, analyticsEvent);
+                delegate.onProductAnalytics?.(analyticsEvent, productId);
+            }
+            catch (err) {
+                delegate.onError?.(err instanceof Error ? err : new Error(String(err)));
+            }
+            return;
+        }
+        if (msg["type"] === "host-bridge-call") {
+            const callId = msg["callId"];
+            const method = msg["method"];
+            const args = msg["args"];
+            if (typeof callId !== "number" ||
+                !Number.isInteger(callId) ||
+                typeof method !== "string" ||
+                !Array.isArray(args))
+                return;
+            handleBridgeCall(bridgeAdapter, method, args, callId, iframe, "null");
+            return;
+        }
+        if (msg["type"] !== "hostapi")
+            return;
+        const raw = msg["data"];
+        const bytes = raw instanceof Uint8Array
+            ? raw
+            : raw instanceof ArrayBuffer
+                ? new Uint8Array(raw)
+                : undefined;
+        if (!bytes)
+            return;
+        try {
+            delegate.onMessage(bytes, productId);
+        }
+        catch (err) {
+            delegate.onError?.(err instanceof Error ? err : new Error(String(err)));
+        }
+    };
+    window.addEventListener("message", onMessage);
+    let initialLoadCompleted = false;
+    let unexpectedNavigationHandled = false;
+    const handleUnexpectedNavigation = () => {
+        if (unexpectedNavigationHandled)
+            return;
+        unexpectedNavigationHandled = true;
+        clearLivenessWatchdog();
+        delegate.onLoadStateChanged?.("failed");
+        delegate.onError?.(new Error(`[product-view] iframe navigated away from the injected product document for product '${productId}'`));
+        // Replace the escaped document with a blank inert page so the host does not
+        // keep rendering untrusted content after a failed sandbox escape attempt.
+        iframe.srcdoc = "<!doctype html><html><body></body></html>";
+    };
+    iframe.addEventListener("load", () => {
+        if (!initialLoadCompleted) {
+            initialLoadCompleted = true;
+            delegate.onLoadStateChanged?.("ready");
+            refreshLivenessWatchdog();
+            return;
+        }
+        handleUnexpectedNavigation();
+    });
+    iframe.addEventListener("error", () => {
+        delegate.onLoadStateChanged?.("failed");
+        delegate.onError?.(new Error(`[product-view] iframe failed to load for product '${productId}'`));
+    });
+    iframe.srcdoc = srcdoc;
+    container.appendChild(iframe);
+    // ---------------------------------------------------------------------------
+    // Handle
+    // ---------------------------------------------------------------------------
+    const sendResponse = (data) => {
+        const cw = iframe.contentWindow;
+        if (cw === null)
+            return;
+        // Use 'null' as the targetOrigin.  The srcdoc iframe's serialized origin
+        // is "null" (sandbox without allow-same-origin), so the browser delivers
+        // the message only to null-origin frames.
+        cw.postMessage({ type: "hostapi-reply", data }, "null");
+    };
+    const destroy = () => {
+        window.removeEventListener("message", onMessage);
+        clearLivenessWatchdog();
+        sandboxGrantPort?.close();
+        sandboxGrantPort = null;
+        iframe.remove();
+        delegate.onLoadStateChanged?.("idle");
+    };
+    // Return InteractiveProductViewHandle with grantNetworkOrigin when interactive.
+    if (enableInteractiveSandbox === true) {
+        const postSandboxGrant = (payload) => {
+            sandboxGrantPort?.postMessage(payload);
+        };
+        const interactiveHandle = {
+            get productId() {
+                return productId;
+            },
+            sendResponse,
+            destroy,
+            grantNetworkOrigin(origin) {
+                // Validate the origin before sending to the iframe.
+                const validated = normalizeApprovedNetworkOrigins([origin]);
+                if (validated.length === 0)
+                    return;
+                postSandboxGrant({
+                    type: "sandbox-grant",
+                    origin: validated[0],
+                    kind: "network",
+                });
+            },
+            grantWebSocketOrigin(origin) {
+                const validated = normalizeApprovedWebSocketOrigins([origin]);
+                if (validated.length === 0)
+                    return;
+                postSandboxGrant({
+                    type: "sandbox-grant",
+                    origin: validated[0],
+                    kind: "websocket",
+                });
+            },
+            grantWebRtcServerUrl(url) {
+                const validated = normalizeApprovedWebRtcServerUrls([url]);
+                if (validated.length === 0)
+                    return;
+                postSandboxGrant({
+                    type: "sandbox-grant",
+                    url: validated[0],
+                    kind: "webrtc",
+                });
+            },
+        };
+        return interactiveHandle;
+    }
+    const handle = {
+        get productId() {
+            return productId;
+        },
+        sendResponse,
+        destroy,
+    };
+    return handle;
+}
+export function mountProductViewUrl(options) {
+    const { container, productId, frameUrl, delegate, enableViolationMonitor, enableInteractiveSandbox, traceContext, analyticsRouter, bridgeAdapter, } = options;
+    if (enableViolationMonitor === true && enableInteractiveSandbox === true) {
+        throw new Error("[product-view] enableViolationMonitor and enableInteractiveSandbox are mutually exclusive");
+    }
+    delegate.onLoadStateChanged?.("loading");
+    const violationRoutingActive = enableViolationMonitor === true || enableInteractiveSandbox === true;
+    const iframe = document.createElement("iframe");
+    // URL-backed archive apps need a same-origin iframe so module scripts and
+    // service-worker-backed asset fetches can resolve under a real route.
+    iframe.setAttribute("sandbox", URL_BACKED_IFRAME_SANDBOX_ATTR);
+    iframe.style.width = "100%";
+    iframe.style.height = "100%";
+    iframe.style.border = "none";
+    const existingSessionToken = resolveProductViewSessionToken(frameUrl);
+    const expectedSessionToken = existingSessionToken ?? createProductViewSessionToken();
+    const effectiveFrameUrl = existingSessionToken !== undefined
+        ? frameUrl
+        : appendProductViewSessionToken(frameUrl, expectedSessionToken);
+    const frameOrigin = new URL(effectiveFrameUrl, window.location.href).origin;
+    let sandboxGrantPort = null;
+    let livenessTimeoutId = null;
+    const clearLivenessWatchdog = () => {
+        if (livenessTimeoutId !== null) {
+            window.clearTimeout(livenessTimeoutId);
+            livenessTimeoutId = null;
+        }
+    };
+    const refreshLivenessWatchdog = () => {
+        clearLivenessWatchdog();
+        livenessTimeoutId = window.setTimeout(() => {
+            handleUnexpectedNavigation();
+        }, 1500);
+    };
+    const onMessage = (event) => {
+        if (unexpectedNavigationHandled)
+            return;
+        if (event.source !== iframe.contentWindow)
+            return;
+        if (event.origin !== frameOrigin)
+            return;
+        const msg = event.data;
+        if (msg === null || typeof msg !== "object")
+            return;
+        if (msg["session"] !== expectedSessionToken)
+            return;
+        if (msg["type"] === "hostapi-heartbeat") {
+            refreshLivenessWatchdog();
+            return;
+        }
+        if (msg["type"] === "hostapi-grant-port") {
+            if (enableInteractiveSandbox === true) {
+                const port = event.ports?.[0];
+                if (port instanceof MessagePort) {
+                    sandboxGrantPort?.close();
+                    sandboxGrantPort = port;
+                    sandboxGrantPort.start();
+                }
+            }
+            return;
+        }
+        if (msg["type"] === "SANDBOX_VIOLATION" && violationRoutingActive) {
+            const now = Date.now();
+            const violation = {
+                api: typeof msg["api"] === "string" ? msg["api"] : String(msg["api"] ?? "unknown"),
+                details: msg["details"] !== null && typeof msg["details"] === "object"
+                    ? msg["details"]
+                    : {},
+                timestamp: typeof msg["timestamp"] === "number" ? msg["timestamp"] : now,
+                hostTimestamp: now,
+                disposition: msg["disposition"] === "promptable" || msg["disposition"] === "always_blocked"
+                    ? msg["disposition"]
+                    : undefined,
+            };
+            try {
+                delegate.onSandboxViolation?.(violation, productId);
+            }
+            catch (err) {
+                delegate.onError?.(err instanceof Error ? err : new Error(String(err)));
+            }
+            return;
+        }
+        if (isProductAnalyticsMessage(msg) && traceContext?.sampled === true) {
+            const analyticsEvent = msg.event;
+            try {
+                analyticsRouter?.dispatch(productId, analyticsEvent);
+                delegate.onProductAnalytics?.(analyticsEvent, productId);
+            }
+            catch (err) {
+                delegate.onError?.(err instanceof Error ? err : new Error(String(err)));
+            }
+            return;
+        }
+        if (msg["type"] === "host-bridge-call") {
+            const callId = msg["callId"];
+            const method = msg["method"];
+            const args = msg["args"];
+            if (typeof callId !== "number" ||
+                !Number.isInteger(callId) ||
+                typeof method !== "string" ||
+                !Array.isArray(args))
+                return;
+            handleBridgeCall(bridgeAdapter, method, args, callId, iframe, frameOrigin, expectedSessionToken);
+            return;
+        }
+        if (msg["type"] !== "hostapi")
+            return;
+        const raw = msg["data"];
+        const bytes = raw instanceof Uint8Array
+            ? raw
+            : raw instanceof ArrayBuffer
+                ? new Uint8Array(raw)
+                : undefined;
+        if (!bytes)
+            return;
+        try {
+            delegate.onMessage(bytes, productId);
+        }
+        catch (err) {
+            delegate.onError?.(err instanceof Error ? err : new Error(String(err)));
+        }
+    };
+    window.addEventListener("message", onMessage);
+    let initialLoadCompleted = false;
+    let unexpectedNavigationHandled = false;
+    const handleUnexpectedNavigation = () => {
+        if (unexpectedNavigationHandled)
+            return;
+        unexpectedNavigationHandled = true;
+        clearLivenessWatchdog();
+        delegate.onLoadStateChanged?.("failed");
+        delegate.onError?.(new Error(`[product-view] iframe lost the injected product bridge for product '${productId}'`));
+        iframe.src = "about:blank";
+    };
+    iframe.addEventListener("load", () => {
+        if (!initialLoadCompleted) {
+            initialLoadCompleted = true;
+            delegate.onLoadStateChanged?.("ready");
+            refreshLivenessWatchdog();
+            return;
+        }
+        handleUnexpectedNavigation();
+    });
+    iframe.addEventListener("error", () => {
+        delegate.onLoadStateChanged?.("failed");
+        delegate.onError?.(new Error(`[product-view] iframe failed to load for product '${productId}'`));
+    });
+    iframe.src = effectiveFrameUrl;
+    container.appendChild(iframe);
+    const sendResponse = (data) => {
+        const cw = iframe.contentWindow;
+        if (cw === null)
+            return;
+        // URL-backed frames keep their real origin, so replies can be pinned to
+        // the exact frame origin instead of the opaque "null" target used by srcdoc.
+        cw.postMessage({ type: "hostapi-reply", data, session: expectedSessionToken }, frameOrigin);
+    };
+    const destroy = () => {
+        window.removeEventListener("message", onMessage);
+        clearLivenessWatchdog();
+        sandboxGrantPort?.close();
+        sandboxGrantPort = null;
+        iframe.remove();
+        delegate.onLoadStateChanged?.("idle");
+    };
+    if (enableInteractiveSandbox === true) {
+        const postSandboxGrant = (payload) => {
+            sandboxGrantPort?.postMessage(payload);
+        };
+        return {
+            get productId() {
+                return productId;
+            },
+            sendResponse,
+            destroy,
+            grantNetworkOrigin(origin) {
+                const validated = normalizeApprovedNetworkOrigins([origin]);
+                if (validated.length === 0)
+                    return;
+                postSandboxGrant({
+                    type: "sandbox-grant",
+                    origin: validated[0],
+                    kind: "network",
+                });
+            },
+            grantWebSocketOrigin(origin) {
+                const validated = normalizeApprovedWebSocketOrigins([origin]);
+                if (validated.length === 0)
+                    return;
+                postSandboxGrant({
+                    type: "sandbox-grant",
+                    origin: validated[0],
+                    kind: "websocket",
+                });
+            },
+            grantWebRtcServerUrl(url) {
+                const validated = normalizeApprovedWebRtcServerUrls([url]);
+                if (validated.length === 0)
+                    return;
+                postSandboxGrant({
+                    type: "sandbox-grant",
+                    url: validated[0],
+                    kind: "webrtc",
+                });
+            },
+        };
+    }
+    return {
+        get productId() {
+            return productId;
+        },
+        sendResponse,
+        destroy,
+    };
+}
+//# sourceMappingURL=product-view.js.map