@tatchi-xyz/sdk 0.20.0 → 0.31.0

package/dist/esm/sdk/router-BEGGuWaB.js

@@ -0,0 +1,1868 @@
+import { extractBorshBytesFromPlainSignedTx, isBoolean, isObject, isPlainSignedTransactionLike, stripFunctionsShallow, toBasePath } from "./validation-BTq6LGPp.js";
+import "./rpc-Dq3ioE9T.js";
+import { mergeSignerMode } from "./signer-worker-DK847sXj.js";
+import "./base64-dqpWgddX.js";
+import { ActionPhase, DeviceLinkingPhase, EmailRecoveryPhase, LoginPhase, RegistrationPhase, SyncAccountPhase } from "./sdkSentEvents-CzAZBFjP.js";
+import { toError } from "./errors-DevlT39D.js";
+import { SignedTransaction, openOfflineExportWindow } from "./overlay-Ci2FOQKE.js";
+import { PASSKEY_MANAGER_DEFAULT_CONFIGS } from "./defaultConfigs-BmCU1_qI.js";
+import { WebAuthnBridgeMessage, serializeAuthenticationCredentialWithPRF, serializeRegistrationCredentialWithPRF } from "./safari-fallbacks-BcMFntiP.js";
+
+//#region src/core/WalletIframe/client/on-events-progress-bus.ts
+const SHOW_PHASES = new Set([
+	ActionPhase.STEP_2_USER_CONFIRMATION,
+	ActionPhase.STEP_2_USER_CONFIRMATION,
+	ActionPhase.STEP_3_WEBAUTHN_AUTHENTICATION,
+	ActionPhase.STEP_3_WEBAUTHN_AUTHENTICATION,
+	RegistrationPhase.STEP_1_WEBAUTHN_VERIFICATION,
+	EmailRecoveryPhase.STEP_2_TOUCH_ID_REGISTRATION,
+	DeviceLinkingPhase.STEP_3_AUTHORIZATION,
+	DeviceLinkingPhase.STEP_6_REGISTRATION,
+	SyncAccountPhase.STEP_2_WEBAUTHN_AUTHENTICATION,
+	LoginPhase.STEP_2_WEBAUTHN_ASSERTION
+]);
+const HIDE_PHASES = new Set([
+	ActionPhase.STEP_4_AUTHENTICATION_COMPLETE,
+	ActionPhase.STEP_5_TRANSACTION_SIGNING_PROGRESS,
+	ActionPhase.STEP_6_TRANSACTION_SIGNING_COMPLETE,
+	ActionPhase.STEP_7_BROADCASTING,
+	ActionPhase.STEP_8_ACTION_COMPLETE,
+	DeviceLinkingPhase.STEP_7_LINKING_COMPLETE,
+	DeviceLinkingPhase.REGISTRATION_ERROR,
+	DeviceLinkingPhase.LOGIN_ERROR,
+	DeviceLinkingPhase.DEVICE_LINKING_ERROR,
+	RegistrationPhase.STEP_5_CONTRACT_REGISTRATION,
+	RegistrationPhase.STEP_8_REGISTRATION_COMPLETE,
+	RegistrationPhase.REGISTRATION_ERROR,
+	LoginPhase.STEP_3_VRF_UNLOCK,
+	LoginPhase.STEP_4_LOGIN_COMPLETE,
+	LoginPhase.LOGIN_ERROR,
+	SyncAccountPhase.STEP_4_AUTHENTICATOR_SAVED,
+	SyncAccountPhase.STEP_5_SYNC_ACCOUNT_COMPLETE,
+	SyncAccountPhase.ERROR,
+	EmailRecoveryPhase.STEP_5_FINALIZING_REGISTRATION,
+	EmailRecoveryPhase.STEP_6_COMPLETE,
+	EmailRecoveryPhase.ERROR
+]);
+var OnEventsProgressBus = class {
+	subs = /* @__PURE__ */ new Map();
+	logger;
+	overlay;
+	heuristic;
+	overlayDemands = /* @__PURE__ */ new Map();
+	constructor(overlay, heuristic, logger) {
+		this.overlay = overlay;
+		this.heuristic = heuristic;
+		this.logger = logger;
+	}
+	/**
+	* Register a subscriber for a requestId.
+	* Initializes demand tracking to 'none' (neutral) until phases arrive.
+	*/
+	register({ requestId, onProgress, sticky = false }) {
+		this.subs.set(requestId, {
+			onProgress,
+			sticky,
+			stats: {
+				count: 0,
+				lastPhase: null,
+				lastAt: null
+			}
+		});
+		this.overlayDemands.set(requestId, "none");
+		this.log("register", {
+			requestId,
+			sticky
+		});
+	}
+	/**
+	* Unregister a subscriber and clear its overlay demand.
+	* If no remaining requests demand 'show', the overlay is hidden.
+	*/
+	unregister(requestId) {
+		if (this.subs.delete(requestId)) this.log("unregister", { requestId });
+		this.overlayDemands.delete(requestId);
+		if (!this.wantsVisible()) try {
+			this.overlay.hide();
+		} catch {}
+	}
+	/**
+	* Remove all subscribers and demands; overlay demand set is cleared.
+	*/
+	clearAll() {
+		this.subs.clear();
+		this.overlayDemands.clear();
+		this.log("clearAll");
+	}
+	isSticky(requestId) {
+		const sub = this.subs.get(requestId);
+		return !!sub?.sticky;
+	}
+	/**
+	* Dispatch a progress payload to a request's subscriber and update
+	* the aggregate overlay demand based on the phase heuristic.
+	*/
+	dispatch({ requestId, payload }) {
+		const phase = String((payload || {}).phase || "");
+		const action = this.heuristic(payload);
+		this.overlayDemands.set(requestId, action);
+		if (action === "show") try {
+			this.overlay.show();
+		} catch {}
+		else if (action === "hide") {
+			if (!this.wantsVisible()) try {
+				this.overlay.hide();
+			} catch {}
+		}
+		const sub = this.subs.get(requestId);
+		if (sub) {
+			this.bumpStats(sub, phase);
+			try {
+				sub.onProgress?.(payload);
+			} catch {}
+			this.log("dispatch", {
+				requestId,
+				phase,
+				sticky: sub.sticky
+			});
+			return true;
+		}
+		const sticky = this.findSticky(requestId);
+		if (sticky) {
+			this.bumpStats(sticky, phase);
+			try {
+				sticky.onProgress?.(payload);
+			} catch {}
+			this.log("dispatch-sticky", {
+				requestId,
+				phase
+			});
+			return true;
+		}
+		this.log("dispatch-miss", {
+			requestId,
+			phase
+		});
+		return false;
+	}
+	getStats(requestId) {
+		const sub = this.subs.get(requestId);
+		return sub ? sub.stats : null;
+	}
+	/**
+	* Returns true if any tracked request currently demands the overlay be visible.
+	* Useful for higher layers (router) to avoid premature hides on completion/timeout.
+	*/
+	wantsVisible() {
+		for (const v of this.overlayDemands.values()) if (v === "show") return true;
+		return false;
+	}
+	findSticky(requestId) {
+		const sub = this.subs.get(requestId);
+		if (sub && sub.sticky) return sub;
+		return null;
+	}
+	bumpStats(sub, phase) {
+		sub.stats.count += 1;
+		sub.stats.lastPhase = phase || null;
+		sub.stats.lastAt = Date.now();
+	}
+	log(msg, data) {
+		try {
+			this.logger?.(msg, data);
+		} catch {}
+	}
+};
+/**
+* defaultPhaseHeuristics
+*
+* Decides when to expand or contract the invisible wallet iframe overlay
+* based on incoming progress events (phases). Returning:
+*  - 'show' → expands the iframe to a full-screen, invisible layer that captures
+*             user activation (e.g., TouchID / WebAuthn prompts) and pointer events.
+*  - 'hide' → immediately contracts the iframe back to 0×0 so it no longer blocks clicks.
+*  - 'none' → no change.
+*
+* Important UX constraint: the overlay covers the entire viewport and is
+* intentionally invisible. While expanded, it will intercept clicks and can
+* block interactions with the app. Therefore, we must minimize the time it is
+* expanded and only show it during the brief windows where user activation is
+* required (e.g., when the TouchID prompt is about to appear or the modal is
+* mounting and needs focus/activation in the iframe context). As soon as
+* activation completes (e.g., authentication-complete), we hide it again.
+*
+* If new phases are introduced that require user activation, add them to
+* SHOW_PHASES; if phases become non-interactive post-activation, add them to
+* HIDE_PHASES. The goal is to keep the overlay up for the minimum possible time.
+*/
+const defaultPhaseHeuristics = (payload) => {
+	try {
+		const phase = String((payload || {}).phase || "");
+		if (!phase) return "none";
+		if (SHOW_PHASES.has(phase)) return "show";
+		if (HIDE_PHASES.has(phase)) return "hide";
+		const raw = phase.toLowerCase();
+		if (raw === "user-confirmation-complete") return "hide";
+		if (raw === "cancelled") return "hide";
+		return "none";
+	} catch {
+		return "none";
+	}
+};
+
+//#endregion
+//#region src/core/WalletIframe/client/overlay-styles.ts
+const CLASS_BASE = "w3a-wallet-overlay";
+const CLASS_HIDDEN = "is-hidden";
+const CLASS_FULLSCREEN = "is-fullscreen";
+const CLASS_ANCHORED = "is-anchored";
+const state = {
+	baseSheet: null,
+	dynStyleEl: null,
+	ruleIndex: /* @__PURE__ */ new Map(),
+	supportConstructable: null
+};
+function supportsConstructable() {
+	if (state.supportConstructable != null) return state.supportConstructable;
+	state.supportConstructable = typeof CSSStyleSheet !== "undefined" && "adoptedStyleSheets" in document;
+	return state.supportConstructable;
+}
+function getNonce() {
+	const w = window;
+	return w.w3aNonce || w.litNonce || void 0;
+}
+function installBaseStyles() {
+	if (state.baseSheet || state.dynStyleEl) return;
+	const css = `
+    .${CLASS_BASE} { position: fixed; border: none; box-sizing: border-box; background: transparent; color-scheme: normal; transform: none; right: auto; bottom: auto; inset: auto; top: auto; left: auto; z-index: var(--w3a-wallet-overlay-z, 2147483646); }
+    .${CLASS_BASE}.${CLASS_HIDDEN} { width: 0px; height: 0px; opacity: 0; pointer-events: none; z-index: auto; }
+    .${CLASS_BASE}.${CLASS_FULLSCREEN} { top: 0; left: 0; right: 0; bottom: 0; inset: 0; opacity: 1; pointer-events: auto; }
+    @supports (width: 100dvw) { .${CLASS_BASE}.${CLASS_FULLSCREEN} { width: 100dvw; height: 100dvh; } }
+    @supports not (width: 100dvw) { .${CLASS_BASE}.${CLASS_FULLSCREEN} { width: 100vw; height: 100vh; } }
+    .${CLASS_BASE}.${CLASS_ANCHORED} { opacity: 1; pointer-events: auto; }
+  `;
+	if (supportsConstructable()) try {
+		state.baseSheet = new CSSStyleSheet();
+		state.baseSheet.replaceSync(css);
+		const current = document.adoptedStyleSheets || [];
+		document.adoptedStyleSheets = [...current, state.baseSheet];
+		return;
+	} catch {}
+	const styleEl = document.createElement("style");
+	const nonce = getNonce();
+	if (nonce) try {
+		styleEl.setAttribute("nonce", nonce);
+	} catch {}
+	styleEl.textContent = css;
+	document.head.appendChild(styleEl);
+}
+function ensureDynStyleEl() {
+	if (state.dynStyleEl) return state.dynStyleEl;
+	const el = document.createElement("style");
+	const nonce = getNonce();
+	if (nonce) try {
+		el.setAttribute("nonce", nonce);
+	} catch {}
+	el.setAttribute("data-w3a-overlay-dyn", "");
+	document.head.appendChild(el);
+	state.dynStyleEl = el;
+	return el;
+}
+function asId(el) {
+	if (el.id && el.id.startsWith("w3a-overlay-")) return el.id;
+	const id = `w3a-overlay-${Math.random().toString(36).slice(2, 9)}`;
+	try {
+		el.id = id;
+	} catch {}
+	return id;
+}
+function ensureOverlayBase(el) {
+	installBaseStyles();
+	try {
+		el.classList.add(CLASS_BASE);
+	} catch {}
+}
+function setHidden(el) {
+	ensureOverlayBase(el);
+	try {
+		el.classList.add(CLASS_HIDDEN);
+		el.classList.remove(CLASS_FULLSCREEN);
+		el.classList.remove(CLASS_ANCHORED);
+	} catch {}
+}
+function setFullscreen(el) {
+	ensureOverlayBase(el);
+	try {
+		el.classList.add(CLASS_FULLSCREEN);
+		el.classList.remove(CLASS_HIDDEN);
+		el.classList.remove(CLASS_ANCHORED);
+	} catch {}
+}
+function setAnchored(el, rect) {
+	ensureOverlayBase(el);
+	const id = asId(el);
+	const top = Math.max(0, Math.round(rect.top));
+	const left = Math.max(0, Math.round(rect.left));
+	const width = Math.max(1, Math.round(rect.width));
+	const height = Math.max(1, Math.round(rect.height));
+	const rule = `#${id}.${CLASS_ANCHORED}{ top:${top}px; left:${left}px; width:${width}px; height:${height}px; }`;
+	if (supportsConstructable() && state.baseSheet) {
+		const s = state.baseSheet;
+		const prev = state.ruleIndex.get(id);
+		try {
+			if (typeof prev === "number") try {
+				s.deleteRule(prev);
+			} catch {}
+			const idx = s.insertRule(rule, s.cssRules.length);
+			state.ruleIndex.set(id, idx);
+		} catch {}
+	} else {
+		const elDyn = ensureDynStyleEl();
+		const lines = (elDyn.textContent || "").split("\n").filter(Boolean);
+		const prefix = `#${id}.`;
+		const rest = lines.filter((l) => !l.startsWith(prefix));
+		rest.push(rule);
+		elDyn.textContent = rest.join("\n");
+	}
+	try {
+		el.classList.add(CLASS_ANCHORED);
+		el.classList.remove(CLASS_HIDDEN);
+		el.classList.remove(CLASS_FULLSCREEN);
+	} catch {}
+}
+
+//#endregion
+//#region src/core/WalletIframe/client/IframeTransport.ts
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const WILDCARD_CONNECT_ATTEMPTS = 6;
+const IframeMessage = {
+	Connect: "CONNECT",
+	Ready: "READY",
+	HostBooted: "SERVICE_HOST_BOOTED",
+	HostDebugOrigin: "SERVICE_HOST_DEBUG_ORIGIN",
+	HostLog: "SERVICE_HOST_LOG"
+};
+var IframeTransport = class {
+	opts;
+	iframeEl = null;
+	serviceBooted = false;
+	connectInFlight = null;
+	walletServiceUrl;
+	walletOrigin;
+	testOptions;
+	debug = false;
+	onWindowMessage = (e) => {
+		const data = e.data;
+		if (!isObject(data)) return;
+		const type = data.type;
+		if (type === IframeMessage.HostDebugOrigin) {
+			if (this.debug) console.debug("[IframeTransport][host-origin]", {
+				origin: data.origin,
+				href: data.href,
+				eventOrigin: e.origin
+			});
+			return;
+		}
+		if (e.origin !== this.walletOrigin) return;
+		if (type === IframeMessage.HostBooted) {
+			this.serviceBooted = true;
+			return;
+		}
+		if (type === IframeMessage.HostLog) {
+			if (this.debug) console.debug("[IframeTransport][wallet-log]", data.payload);
+			return;
+		}
+		if (type === WebAuthnBridgeMessage.Create || type === WebAuthnBridgeMessage.Get) this.performWebAuthnBridge(type, data, e);
+	};
+	constructor(options) {
+		this.opts = {
+			servicePath: "/wallet-service",
+			connectTimeoutMs: 8e3,
+			debug: false,
+			...options
+		};
+		try {
+			this.walletServiceUrl = new URL(this.opts.servicePath, this.opts.walletOrigin);
+		} catch (err) {
+			throw new Error(`[IframeTransport] Invalid wallet origin (${options.walletOrigin}) or servicePath (${options.servicePath || "/wallet-service"})`);
+		}
+		this.walletOrigin = this.walletServiceUrl.origin;
+		this.testOptions = {
+			routerId: options.testOptions?.routerId,
+			ownerTag: options.testOptions?.ownerTag
+		};
+		this.debug = !!this.opts.debug;
+		if (typeof window !== "undefined") window.addEventListener("message", this.onWindowMessage);
+	}
+	/** Returns the underlying iframe element if it exists. */
+	getIframeEl() {
+		return this.iframeEl;
+	}
+	/** Remove global listeners created by this transport instance. */
+	dispose() {
+		if (typeof window !== "undefined") window.removeEventListener("message", this.onWindowMessage);
+	}
+	isDevHost() {
+		if (typeof window === "undefined") return false;
+		const env = globalThis?.process?.env?.NODE_ENV;
+		if (env && env !== "production") return true;
+		const h = window.location.hostname || "";
+		return /localhost|127\.(?:0|[1-9]\d?)\.(?:0|[1-9]\d?)\.(?:0|[1-9]\d?)|\.local(?:host)?$/i.test(h);
+	}
+	isOverlayForOrigin(el) {
+		const dsOrigin = el.dataset?.w3aOrigin;
+		if (dsOrigin) return dsOrigin === this.walletOrigin;
+		try {
+			return new URL(el.src).origin === this.walletOrigin;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Guardrail: prevent multiple overlay iframes accumulating when apps accidentally
+	* create more than one WalletIframeRouter/TatchiPasskey instance.
+	*/
+	removeExistingOverlaysForOrigin() {
+		if (typeof document === "undefined") return;
+		const existing = Array.from(document.querySelectorAll("iframe.w3a-wallet-overlay"));
+		const matches = existing.filter((el) => this.isOverlayForOrigin(el));
+		if (!matches.length) return;
+		if (this.isDevHost()) {
+			const routerIds = matches.map((el) => el.dataset?.w3aRouterId).filter((v) => typeof v === "string" && v.length > 0);
+			console.warn(`[IframeTransport] Found existing wallet overlay iframe(s) for ${this.walletOrigin}. This usually indicates multiple SDK instances. Removing old iframe(s) to avoid duplicates.`, {
+				count: matches.length,
+				routerIds
+			});
+		}
+		for (const el of matches) try {
+			el.remove();
+		} catch {}
+	}
+	/** Ensure the iframe element exists and is appended to the DOM. Idempotent. */
+	ensureIframeMounted() {
+		if (this.iframeEl) return this.iframeEl;
+		this.removeExistingOverlaysForOrigin();
+		const iframe = document.createElement("iframe");
+		iframe.classList.add("w3a-wallet-overlay", "is-hidden");
+		try {
+			ensureOverlayBase(iframe);
+		} catch {}
+		iframe.setAttribute("width", "0");
+		iframe.setAttribute("height", "0");
+		iframe.setAttribute("aria-hidden", "true");
+		iframe.setAttribute("tabindex", "-1");
+		iframe.setAttribute("loading", "eager");
+		iframe.setAttribute("fetchpriority", "high");
+		iframe.dataset.w3aRouterId = this.testOptions?.routerId || "";
+		if (this.testOptions?.ownerTag) iframe.dataset.w3aOwner = this.testOptions.ownerTag;
+		iframe.dataset.w3aOrigin = this.walletOrigin;
+		try {
+			iframe.setAttribute("allow", this.buildAllowAttr(this.walletOrigin));
+		} catch {
+			iframe.setAttribute("allow", "publickey-credentials-get 'self'; publickey-credentials-create 'self'; clipboard-read; clipboard-write");
+		}
+		iframe._svc_loaded = false;
+		iframe.addEventListener("load", () => {
+			iframe._svc_loaded = true;
+		}, { once: true });
+		const src = this.walletServiceUrl.toString();
+		console.debug("[IframeTransport] mount: external origin", src);
+		iframe.src = src;
+		document.body.appendChild(iframe);
+		console.debug("[IframeTransport] mount: iframe appended");
+		this.iframeEl = iframe;
+		return iframe;
+	}
+	/**
+	* Connect to the wallet iframe using a MessageChannel handshake.
+	* - Repeatedly posts {type:'CONNECT'} with a fresh port until a 'READY' message arrives
+	* - Times out after connectTimeoutMs
+	* - Deduplicates concurrent calls and returns the same MessagePort promise
+	*/
+	async connect() {
+		if (this.connectInFlight) return this.connectInFlight;
+		this.connectInFlight = (async () => {
+			const iframe = this.ensureIframeMounted();
+			await this.waitForLoad(iframe);
+			const bootWaitMs = Math.min(this.opts.connectTimeoutMs / 12, 300);
+			await this.waitForBootHint(bootWaitMs);
+			return this.handshake(iframe);
+		})();
+		try {
+			return await this.connectInFlight;
+		} finally {
+			this.connectInFlight = null;
+		}
+	}
+	async waitForBootHint(timeoutMs) {
+		if (this.serviceBooted || timeoutMs <= 0) return;
+		const start = Date.now();
+		while (!this.serviceBooted && Date.now() - start < timeoutMs) await sleep(50);
+	}
+	async handshake(iframe) {
+		let resolved = false;
+		let attempt = 0;
+		let warnedNullOrigin = false;
+		const start = Date.now();
+		const overallTimeout = this.opts.connectTimeoutMs;
+		return await new Promise((resolve, reject) => {
+			const tick = () => {
+				if (resolved) return;
+				const elapsed = Date.now() - start;
+				if (elapsed >= overallTimeout) {
+					resolved = true;
+					console.debug("[IframeTransport] handshake timeout after %d ms", elapsed);
+					return reject(/* @__PURE__ */ new Error("Wallet iframe READY timeout"));
+				}
+				attempt += 1;
+				const channel = new MessageChannel();
+				const port1 = channel.port1;
+				const port2 = channel.port2;
+				const cleanup = () => {
+					try {
+						port1.onmessage = null;
+					} catch {}
+				};
+				port1.onmessage = (e) => {
+					const data = e.data;
+					if (data.type === IframeMessage.Ready) {
+						resolved = true;
+						cleanup();
+						port1.start?.();
+						return resolve(port1);
+					}
+				};
+				try {
+					port1.start?.();
+				} catch {}
+				const cw = iframe.contentWindow;
+				if (!cw) {
+					resolved = true;
+					cleanup();
+					return reject(/* @__PURE__ */ new Error("Wallet iframe window missing"));
+				}
+				const targetOrigin = this.getConnectTargetOrigin(attempt);
+				({warnedNullOrigin} = this.postConnectMessage(cw, { type: IframeMessage.Connect }, port2, targetOrigin, warnedNullOrigin, elapsed, attempt));
+				const interval = attempt < 10 ? 200 : attempt < 20 ? 400 : 800;
+				setTimeout(() => {
+					if (!resolved) tick();
+				}, interval);
+			};
+			tick();
+		});
+	}
+	getConnectTargetOrigin(attempt) {
+		if (this.serviceBooted) return this.walletOrigin;
+		if (attempt <= WILDCARD_CONNECT_ATTEMPTS) return "*";
+		return this.walletOrigin;
+	}
+	postConnectMessage(cw, data, port2, targetOrigin, warnedNullOrigin, elapsed, attempt) {
+		try {
+			cw.postMessage(data, targetOrigin, [port2]);
+			return { warnedNullOrigin };
+		} catch (e) {
+			const message = e instanceof Error ? e.message ?? String(e) : String(e);
+			if (!warnedNullOrigin && message.includes("'null'")) {
+				warnedNullOrigin = true;
+				console.warn("[IframeTransport] CONNECT blocked; iframe origin appears to be null. Check that %s is reachable and responds with Cross-Origin-Resource-Policy: cross-origin.", this.walletServiceUrl.toString());
+			}
+			try {
+				cw.postMessage(data, "*", [port2]);
+			} catch {}
+			console.debug("[IframeTransport] CONNECT attempt %d threw after %d ms; retrying.", attempt, elapsed);
+			return { warnedNullOrigin };
+		}
+	}
+	/** Guard against posting to the iframe before it has fired load. */
+	async waitForLoad(iframe) {
+		if (iframe._svc_loaded) return;
+		await new Promise((resolve) => {
+			let done = false;
+			const finish = () => {
+				if (done) return;
+				done = true;
+				resolve();
+			};
+			const timeout = window.setTimeout(() => {
+				if (!done && this.debug) console.debug("[IframeTransport] waitForLoad did not observe load event within 150ms; continuing");
+				finish();
+			}, 150);
+			iframe.addEventListener("load", () => {
+				clearTimeout(timeout);
+				finish();
+			}, { once: true });
+		});
+	}
+	buildAllowAttr(walletOrigin) {
+		return `publickey-credentials-get 'self' ${walletOrigin}; publickey-credentials-create 'self' ${walletOrigin}; clipboard-read; clipboard-write`;
+	}
+	formatBridgeError(err) {
+		return err instanceof Error ? err.message : String(err);
+	}
+	postBridgeResult(source, type, requestId, ok, payload) {
+		source?.postMessage({
+			type,
+			requestId,
+			ok,
+			...payload
+		}, "*");
+	}
+	performWebAuthnBridge(kind, raw, e) {
+		if (kind === WebAuthnBridgeMessage.Create) {
+			this.handleWebAuthnCreate(raw, e);
+			return;
+		}
+		this.handleWebAuthnGet(raw, e);
+	}
+	async handleWebAuthnCreate(req, e) {
+		const requestId = req?.requestId || "";
+		if (!isObject(req?.publicKey)) {
+			this.postBridgeResult(e.source, WebAuthnBridgeMessage.CreateResult, requestId, false, { error: "publicKey options required" });
+			return;
+		}
+		if (!navigator.credentials?.create) {
+			this.postBridgeResult(e.source, WebAuthnBridgeMessage.CreateResult, requestId, false, { error: "WebAuthn create not available" });
+			return;
+		}
+		try {
+			const src = req.publicKey;
+			const rpName = src.rp?.name || "WebAuthn";
+			const rpId = src.rp?.id || window.location.hostname;
+			const pub = {
+				...src,
+				rp: {
+					name: rpName,
+					id: rpId
+				}
+			};
+			const cred = await navigator.credentials.create({ publicKey: pub });
+			const serialized = serializeRegistrationCredentialWithPRF({
+				credential: cred,
+				firstPrfOutput: true,
+				secondPrfOutput: true
+			});
+			this.postBridgeResult(e.source, WebAuthnBridgeMessage.CreateResult, requestId, true, { credential: serialized });
+		} catch (err) {
+			const message = this.formatBridgeError(err);
+			console.warn("[IframeTransport][bridge] CREATE failed", {
+				requestId,
+				err: message
+			});
+			this.postBridgeResult(e.source, WebAuthnBridgeMessage.CreateResult, requestId, false, { error: message });
+		}
+	}
+	async handleWebAuthnGet(req, e) {
+		const requestId = req?.requestId || "";
+		if (!isObject(req?.publicKey)) {
+			this.postBridgeResult(e.source, WebAuthnBridgeMessage.GetResult, requestId, false, { error: "publicKey options required" });
+			return;
+		}
+		if (!navigator.credentials?.get) {
+			this.postBridgeResult(e.source, WebAuthnBridgeMessage.GetResult, requestId, false, { error: "WebAuthn get not available" });
+			return;
+		}
+		try {
+			const src = req.publicKey;
+			const rpId = src.rpId || window.location.hostname;
+			const pub = {
+				...src,
+				rpId
+			};
+			const cred = await navigator.credentials.get({ publicKey: pub });
+			const serialized = serializeAuthenticationCredentialWithPRF({
+				credential: cred,
+				firstPrfOutput: true,
+				secondPrfOutput: true
+			});
+			this.postBridgeResult(e.source, WebAuthnBridgeMessage.GetResult, requestId, true, { credential: serialized });
+		} catch (err) {
+			const message = this.formatBridgeError(err);
+			console.warn("[IframeTransport][bridge] GET failed", {
+				requestId,
+				err: message
+			});
+			this.postBridgeResult(e.source, WebAuthnBridgeMessage.GetResult, requestId, false, { error: message });
+		}
+	}
+};
+
+//#endregion
+//#region src/core/WalletIframe/client/overlay-controller.ts
+var OverlayController = class {
+	ensureIframe;
+	mode = "hidden";
+	visible = false;
+	sticky = false;
+	rect = null;
+	constructor(opts) {
+		this.ensureIframe = opts.ensureIframe;
+	}
+	/**
+	* Set sticky mode - prevents overlay from being hidden during critical operations
+	* When sticky=true, hide() calls are ignored to maintain overlay visibility
+	*/
+	setSticky(v) {
+		this.sticky = !!v;
+	}
+	/**
+	* Show overlay in fullscreen mode - covers the viewport
+	* Used for WebAuthn activation where user needs to interact with TouchID/FaceID
+	* This mode allows the iframe to receive user activation events
+	*/
+	showFullscreen() {
+		const iframe = this.ensureIframe();
+		this.visible = true;
+		this.mode = "fullscreen";
+		this.rect = null;
+		setFullscreen(iframe);
+		iframe.setAttribute("aria-hidden", "false");
+		iframe.removeAttribute("tabindex");
+	}
+	/**
+	* Show overlay in anchored mode - positioned at specific coordinates
+	* Used for inline UI components that need to appear at a specific location
+	* Coordinates are viewport-relative (from getBoundingClientRect()); values are
+	* clamped to non-negative top/left and minimum width/height
+	*/
+	showAnchored(rect) {
+		const iframe = this.ensureIframe();
+		this.visible = true;
+		this.mode = "anchored";
+		this.rect = { ...rect };
+		setAnchored(iframe, rect);
+		iframe.setAttribute("aria-hidden", "false");
+		iframe.removeAttribute("tabindex");
+	}
+	/**
+	* Update anchored rectangle coordinates
+	* If overlay is currently in anchored mode, immediately apply new position
+	*/
+	setAnchoredRect(rect) {
+		this.rect = { ...rect };
+		if (this.visible && this.mode === "anchored") this.showAnchored(this.rect);
+	}
+	/**
+	* Show overlay preferring anchored mode when a rect is available.
+	* Falls back to fullscreen when no anchored rect has been set yet.
+	* Safe to call repeatedly; it will re-apply current state.
+	*/
+	showPreferAnchored() {
+		if (this.rect) this.showAnchored(this.rect);
+		else this.showFullscreen();
+	}
+	/**
+	* Clear anchored rectangle - removes stored coordinates
+	*/
+	clearAnchoredRect() {
+		this.rect = null;
+	}
+	/**
+	* Hide overlay - makes iframe invisible with no footprint
+	* Respects sticky mode - won't hide if sticky=true
+	* Used when WebAuthn activation is complete or operation is cancelled
+	*/
+	hide() {
+		if (this.sticky) return;
+		const iframe = this.ensureIframe();
+		this.visible = false;
+		this.mode = "hidden";
+		setHidden(iframe);
+		iframe.setAttribute("aria-hidden", "true");
+		iframe.setAttribute("tabindex", "-1");
+	}
+	getState() {
+		return {
+			visible: this.visible,
+			mode: this.mode,
+			sticky: this.sticky,
+			rect: this.rect || void 0
+		};
+	}
+};
+var overlay_controller_default = OverlayController;
+
+//#endregion
+//#region src/core/WalletIframe/client/router.ts
+var WalletIframeRouter = class {
+	opts;
+	transport;
+	state = {
+		port: null,
+		ready: false,
+		initInFlight: null,
+		pending: /* @__PURE__ */ new Map(),
+		reqCounter: 0,
+		signerModePreference: null,
+		device2StartPromise: null
+	};
+	listeners = {
+		ready: /* @__PURE__ */ new Set(),
+		vrfStatus: /* @__PURE__ */ new Set(),
+		preferencesChanged: /* @__PURE__ */ new Set(),
+		registerOverlayResult: /* @__PURE__ */ new Set(),
+		registerOverlaySubmit: /* @__PURE__ */ new Set()
+	};
+	progressBus;
+	debug = false;
+	walletOriginUrl;
+	walletOriginOrigin;
+	overlayState;
+	windowMsgHandlerBound;
+	constructor(options) {
+		if (!options?.walletOrigin) throw new Error("[WalletIframeRouter] walletOrigin is required when using the wallet iframe");
+		let parsedOrigin;
+		try {
+			parsedOrigin = new URL(options.walletOrigin);
+		} catch (err) {
+			throw new Error(`[WalletIframeRouter] Invalid walletOrigin: ${options.walletOrigin}`);
+		}
+		if (typeof window !== "undefined") {
+			const parentOrigin = window.location.origin;
+			if (parsedOrigin.origin === parentOrigin) console.warn("[WalletIframeRouter] walletOrigin matches the host origin. Isolation safeguards rely on the parent; consider moving the wallet to a dedicated origin.");
+		}
+		const defaultRouterId = `w3a-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+		const testOptions = {
+			routerId: defaultRouterId,
+			ownerTag: void 0,
+			autoMount: true,
+			...options?.testOptions || {}
+		};
+		const normalizedServicePath = (() => {
+			const p = toBasePath(options?.servicePath, "/wallet-service");
+			return p === "/" ? "/wallet-service" : p;
+		})();
+		const normalizedSdkBasePath = (() => {
+			const p = toBasePath(options?.sdkBasePath, "/sdk");
+			return p === "/" ? "/sdk" : p;
+		})();
+		this.opts = {
+			connectTimeoutMs: 8e3,
+			requestTimeoutMs: 2e4,
+			...options,
+			servicePath: normalizedServicePath,
+			sdkBasePath: normalizedSdkBasePath,
+			testOptions,
+			signerMode: options.signerMode ?? PASSKEY_MANAGER_DEFAULT_CONFIGS.signerMode
+		};
+		this.walletOriginUrl = parsedOrigin;
+		this.walletOriginOrigin = parsedOrigin.origin;
+		this.debug = !!this.opts.debug;
+		this.transport = new IframeTransport({
+			walletOrigin: this.opts.walletOrigin,
+			servicePath: this.opts.servicePath,
+			connectTimeoutMs: this.opts.connectTimeoutMs,
+			debug: this.debug,
+			testOptions: {
+				routerId: this.opts.testOptions.routerId,
+				ownerTag: this.opts.testOptions.ownerTag
+			}
+		});
+		this.overlayState = {
+			controller: new overlay_controller_default({ ensureIframe: () => this.transport.ensureIframeMounted() }),
+			forceFullscreen: false
+		};
+		this.progressBus = new OnEventsProgressBus({
+			show: () => this.showFrameForActivation(),
+			hide: () => this.hideFrameForActivation()
+		}, defaultPhaseHeuristics, this.debug ? (msg, data) => {
+			console.debug("[WalletIframeRouter][OnEventsProgressBus]", msg, data || {});
+		} : void 0);
+		this.windowMsgHandlerBound = (ev) => {
+			if (ev.origin !== this.walletOriginOrigin) return;
+			const data = ev.data;
+			if (!data || typeof data !== "object") return;
+			const type = data.type;
+			if (type === "REGISTER_BUTTON_SUBMIT") {
+				this.overlayState.forceFullscreen = true;
+				this.overlayState.controller.setSticky(true);
+				this.overlayState.controller.showFullscreen();
+				for (const cb of Array.from(this.listeners.registerOverlaySubmit)) try {
+					cb();
+				} catch {}
+				return;
+			}
+			if (type === "REGISTER_BUTTON_RESULT") {
+				const payload = data.payload;
+				const ok = !!payload?.ok;
+				for (const cb of Array.from(this.listeners.registerOverlayResult)) cb({
+					ok,
+					result: payload?.result,
+					cancelled: payload?.cancelled,
+					error: payload?.error
+				});
+				this.overlayState.forceFullscreen = false;
+				this.overlayState.controller.setSticky(false);
+				this.hideFrameForActivation();
+				if (ok) {
+					const acct = payload?.result?.nearAccountId;
+					this.getLoginSession(acct).then(({ login: st }) => {
+						this.emitVrfStatusChanged({
+							active: !!st.vrfActive,
+							nearAccountId: st.nearAccountId,
+							sessionDuration: st.vrfSessionDuration
+						});
+					}).catch(() => {});
+				}
+				return;
+			}
+		};
+		globalThis.addEventListener?.("message", this.windowMsgHandlerBound);
+	}
+	attachExportUiClosedListener = (walletOrigin) => {
+		const onUiClosed = (ev) => {
+			if (ev.origin !== walletOrigin) return;
+			const data = ev.data;
+			if (!data || data.type !== "WALLET_UI_CLOSED") return;
+			this.overlayState.controller.setSticky(false);
+			this.hideFrameForActivation();
+			globalThis.removeEventListener?.("message", onUiClosed);
+		};
+		globalThis.addEventListener?.("message", onUiClosed);
+		return () => {
+			globalThis.removeEventListener?.("message", onUiClosed);
+		};
+	};
+	attachExportUiFallbackListener = (walletOrigin, accountId) => {
+		const onFallback = async (ev) => {
+			if (ev.origin !== walletOrigin) return;
+			const data = ev.data;
+			if (!data || data.type !== "OFFLINE_EXPORT_FALLBACK") return;
+			globalThis.removeEventListener?.("message", onFallback);
+			this.overlayState.controller.setSticky(false);
+			this.hideFrameForActivation();
+			await this.openOfflineExport({ accountId });
+		};
+		globalThis.addEventListener?.("message", onFallback);
+		return () => {
+			globalThis.removeEventListener?.("message", onFallback);
+		};
+	};
+	/**
+	* Subscribe to service-ready event. Returns an unsubscribe function.
+	* If already ready, the listener is invoked on next microtask.
+	*/
+	onReady(listener) {
+		if (this.state.ready) {
+			Promise.resolve().then(() => {
+				listener();
+			});
+			return () => {};
+		}
+		this.listeners.ready.add(listener);
+		return () => {
+			this.listeners.ready.delete(listener);
+		};
+	}
+	emitReady() {
+		if (!this.listeners.ready.size) return;
+		for (const cb of Array.from(this.listeners.ready)) cb();
+	}
+	resolveSignerMode(input) {
+		const base = this.state.signerModePreference ?? this.opts.signerMode;
+		return mergeSignerMode(base, input ?? null);
+	}
+	/**
+	* Initialize the transport and configure the wallet host.
+	* Safe to call multiple times; concurrent calls deduplicate via initInFlight.
+	*/
+	async init() {
+		if (this.state.ready) return;
+		if (this.state.initInFlight) return this.state.initInFlight;
+		this.state.initInFlight = (async () => {
+			if (this.opts.testOptions.autoMount !== false) {
+				this.state.port = await this.transport.connect();
+				this.state.port.onmessage = (ev) => this.onPortMessage(ev);
+				this.state.port.start?.();
+				this.state.ready = true;
+			}
+			console.debug("[WalletIframeRouter] init: %s", this.state.ready ? "connected" : "deferred (autoMount=false)");
+			await this.post({
+				type: "PM_SET_CONFIG",
+				payload: {
+					theme: this.opts.theme,
+					signerMode: this.opts.signerMode,
+					nearRpcUrl: this.opts.nearRpcUrl,
+					nearNetwork: this.opts.nearNetwork,
+					contractId: this.opts.contractId,
+					nearExplorerUrl: this.opts.nearExplorerUrl,
+					relayer: this.opts.relayer,
+					vrfWorkerConfigs: this.opts.vrfWorkerConfigs,
+					rpIdOverride: this.opts.rpIdOverride,
+					authenticatorOptions: this.opts.authenticatorOptions,
+					emailRecoveryContracts: this.opts.emailRecoveryContracts,
+					uiRegistry: this.opts.uiRegistry,
+					assetsBaseUrl: (() => {
+						try {
+							const base = new URL(this.opts.sdkBasePath, this.walletOriginUrl).toString();
+							return base.endsWith("/") ? base : `${base}/`;
+						} catch {
+							const fallback = new URL("/sdk/", this.walletOriginUrl).toString();
+							return fallback.endsWith("/") ? fallback : `${fallback}/`;
+						}
+					})()
+				}
+			});
+			this.emitReady();
+		})();
+		try {
+			await this.state.initInFlight;
+		} finally {
+			this.state.initInFlight = null;
+		}
+	}
+	isReady() {
+		return this.state.ready;
+	}
+	registerUiTypes(registry) {
+		const iframe = this.transport.ensureIframeMounted();
+		const w = iframe.contentWindow;
+		if (!w) return;
+		const target = this.walletOriginOrigin;
+		this.postWindowMessage(w, {
+			type: "WALLET_UI_REGISTER_TYPES",
+			payload: registry
+		}, target);
+	}
+	mountUiComponent(params) {
+		const iframe = this.transport.ensureIframeMounted();
+		const w = iframe.contentWindow;
+		if (!w) return;
+		const target = this.walletOriginOrigin;
+		this.postWindowMessage(w, {
+			type: "WALLET_UI_MOUNT",
+			payload: params
+		}, target);
+	}
+	updateUiComponent(params) {
+		const iframe = this.transport.ensureIframeMounted();
+		const w = iframe.contentWindow;
+		if (!w) return;
+		const target = this.walletOriginOrigin;
+		this.postWindowMessage(w, {
+			type: "WALLET_UI_UPDATE",
+			payload: params
+		}, target);
+	}
+	unmountUiComponent(id) {
+		const iframe = this.transport.ensureIframeMounted();
+		const w = iframe.contentWindow;
+		if (!w) return;
+		const target = this.walletOriginOrigin;
+		this.postWindowMessage(w, {
+			type: "WALLET_UI_UNMOUNT",
+			payload: { id }
+		}, target);
+	}
+	onVrfStatusChanged(listener) {
+		this.listeners.vrfStatus.add(listener);
+		return () => {
+			this.listeners.vrfStatus.delete(listener);
+		};
+	}
+	onPreferencesChanged(listener) {
+		this.listeners.preferencesChanged.add(listener);
+		return () => {
+			this.listeners.preferencesChanged.delete(listener);
+		};
+	}
+	emitVrfStatusChanged(status) {
+		for (const cb of Array.from(this.listeners.vrfStatus)) try {
+			cb(status);
+		} catch {}
+	}
+	emitPreferencesChanged(payload) {
+		if (!this.listeners.preferencesChanged.size) return;
+		for (const cb of Array.from(this.listeners.preferencesChanged)) try {
+			cb(payload);
+		} catch {}
+	}
+	onRegisterOverlayResult(listener) {
+		this.listeners.registerOverlayResult.add(listener);
+		return () => {
+			this.listeners.registerOverlayResult.delete(listener);
+		};
+	}
+	onRegisterOverlaySubmit(listener) {
+		this.listeners.registerOverlaySubmit.add(listener);
+		return () => {
+			this.listeners.registerOverlaySubmit.delete(listener);
+		};
+	}
+	async signTransactionsWithActions(payload) {
+		const safeOptions = {
+			signerMode: this.resolveSignerMode(payload.options.signerMode),
+			...payload.options.confirmationConfig ? { confirmationConfig: payload.options.confirmationConfig } : {},
+			...payload.options.confirmerText ? { confirmerText: payload.options.confirmerText } : {}
+		};
+		const res = await this.post({
+			type: "PM_SIGN_TXS_WITH_ACTIONS",
+			payload: {
+				nearAccountId: payload.nearAccountId,
+				transactions: payload.transactions,
+				options: safeOptions
+			},
+			options: { onProgress: this.wrapOnEvent(payload.options?.onEvent, isActionSSEEvent) }
+		});
+		return normalizeSignedTransactionObject(res.result);
+	}
+	async signDelegateAction(payload) {
+		const safeOptions = {
+			signerMode: this.resolveSignerMode(payload.options.signerMode),
+			...payload.options.confirmationConfig ? { confirmationConfig: payload.options.confirmationConfig } : {},
+			...payload.options.confirmerText ? { confirmerText: payload.options.confirmerText } : {}
+		};
+		const res = await this.post({
+			type: "PM_SIGN_DELEGATE_ACTION",
+			payload: {
+				nearAccountId: payload.nearAccountId,
+				delegate: payload.delegate,
+				options: safeOptions
+			},
+			options: { onProgress: this.wrapOnEvent(payload.options?.onEvent, isActionSSEEvent) }
+		});
+		return res.result;
+	}
+	async registerPasskey(payload) {
+		this.overlayState.forceFullscreen = true;
+		this.overlayState.controller.setSticky(true);
+		this.overlayState.controller.showFullscreen();
+		try {
+			if (payload.confirmationConfig) {
+				const base = await this.getConfirmationConfig();
+				await this.setConfirmationConfig({
+					...base,
+					...payload.confirmationConfig
+				});
+			}
+			const safeOptions = removeFunctionsFromOptions(payload.options);
+			const res = await this.post({
+				type: "PM_REGISTER",
+				payload: {
+					nearAccountId: payload.nearAccountId,
+					options: safeOptions,
+					...payload.confirmationConfig ? { confirmationConfig: payload.confirmationConfig } : {}
+				},
+				options: { onProgress: this.wrapOnEvent(payload.options?.onEvent, isRegistrationSSEEvent) }
+			});
+			const { login: st } = await this.getLoginSession(payload.nearAccountId);
+			this.emitVrfStatusChanged({
+				active: !!st.vrfActive,
+				nearAccountId: st.nearAccountId,
+				sessionDuration: st.vrfSessionDuration
+			});
+			return res?.result;
+		} finally {
+			this.overlayState.forceFullscreen = false;
+			this.overlayState.controller.setSticky(false);
+			this.hideFrameForActivation();
+		}
+	}
+	async enrollThresholdEd25519Key(payload) {
+		this.showFrameForActivation();
+		try {
+			const safeOptions = removeFunctionsFromOptions(payload.options);
+			const res = await this.post({
+				type: "PM_ENROLL_THRESHOLD_ED25519_KEY",
+				payload: {
+					nearAccountId: payload.nearAccountId,
+					options: safeOptions
+				}
+			});
+			return res.result;
+		} finally {
+			this.hideFrameForActivation();
+		}
+	}
+	async rotateThresholdEd25519Key(payload) {
+		this.showFrameForActivation();
+		try {
+			const safeOptions = removeFunctionsFromOptions(payload.options);
+			const res = await this.post({
+				type: "PM_ROTATE_THRESHOLD_ED25519_KEY",
+				payload: {
+					nearAccountId: payload.nearAccountId,
+					options: safeOptions
+				}
+			});
+			return res.result;
+		} finally {
+			this.hideFrameForActivation();
+		}
+	}
+	async loginAndCreateSession(payload) {
+		this.showFrameForActivation();
+		try {
+			const safeOptions = removeFunctionsFromOptions(payload.options);
+			const res = await this.post({
+				type: "PM_LOGIN",
+				payload: {
+					nearAccountId: payload.nearAccountId,
+					options: safeOptions
+				},
+				options: { onProgress: this.wrapOnEvent(payload.options?.onEvent, isLoginSSEEvent) }
+			});
+			const { login: st } = await this.getLoginSession(payload.nearAccountId);
+			this.emitVrfStatusChanged({
+				active: !!st.vrfActive,
+				nearAccountId: st.nearAccountId,
+				sessionDuration: st.vrfSessionDuration
+			});
+			return res?.result;
+		} finally {
+			this.hideFrameForActivation();
+		}
+	}
+	async getLoginSession(nearAccountId) {
+		const res = await this.post({
+			type: "PM_GET_LOGIN_SESSION",
+			payload: nearAccountId ? { nearAccountId } : void 0
+		});
+		return res.result;
+	}
+	async checkVrfStatus() {
+		const { login: st } = await this.getLoginSession();
+		return {
+			ok: true,
+			result: {
+				active: !!st.vrfActive,
+				nearAccountId: st.nearAccountId,
+				sessionDuration: st.vrfSessionDuration
+			}
+		};
+	}
+	async clearVrfSession() {
+		await this.post({ type: "PM_LOGOUT" });
+		this.emitVrfStatusChanged({
+			active: false,
+			nearAccountId: null
+		});
+		return {
+			ok: true,
+			result: void 0
+		};
+	}
+	async signNep413Message(payload) {
+		const safeOptions = {
+			signerMode: this.resolveSignerMode(payload.options.signerMode),
+			...payload.options.confirmerText ? { confirmerText: payload.options.confirmerText } : {},
+			...payload.options.confirmationConfig ? { confirmationConfig: payload.options.confirmationConfig } : {}
+		};
+		const res = await this.post({
+			type: "PM_SIGN_NEP413",
+			payload: {
+				nearAccountId: payload.nearAccountId,
+				params: {
+					message: payload.message,
+					recipient: payload.recipient,
+					state: payload.state
+				},
+				options: safeOptions
+			},
+			options: { onProgress: this.wrapOnEvent(payload.options?.onEvent, isActionSSEEvent) }
+		});
+		return res.result;
+	}
+	async signTransactionWithKeyPair(payload) {
+		const { options } = payload;
+		const res = await this.post({
+			type: "PM_SEND_TRANSACTION",
+			payload: {
+				signedTransaction: payload.signedTransaction,
+				options
+			},
+			options: { onProgress: this.wrapOnEvent(options?.onEvent, isActionSSEEvent) }
+		});
+		return res.result;
+	}
+	async executeAction(payload) {
+		const { options } = payload;
+		const safeOptions = {
+			signerMode: this.resolveSignerMode(options.signerMode),
+			waitUntil: options.waitUntil,
+			confirmationConfig: options.confirmationConfig,
+			...options.confirmerText ? { confirmerText: options.confirmerText } : {}
+		};
+		const res = await this.post({
+			type: "PM_EXECUTE_ACTION",
+			payload: {
+				nearAccountId: payload.nearAccountId,
+				receiverId: payload.receiverId,
+				actionArgs: payload.actionArgs,
+				options: safeOptions
+			},
+			options: { onProgress: this.wrapOnEvent(options?.onEvent, isActionSSEEvent) }
+		});
+		return res.result;
+	}
+	async setConfirmBehavior(behavior) {
+		let { nearAccountId } = (await this.getLoginSession()).login;
+		await this.post({
+			type: "PM_SET_CONFIRM_BEHAVIOR",
+			payload: {
+				behavior,
+				nearAccountId
+			}
+		});
+	}
+	async setConfirmationConfig(config) {
+		let { nearAccountId } = (await this.getLoginSession()).login;
+		await this.post({
+			type: "PM_SET_CONFIRMATION_CONFIG",
+			payload: {
+				config,
+				nearAccountId
+			}
+		});
+	}
+	async getConfirmationConfig() {
+		const res = await this.post({ type: "PM_GET_CONFIRMATION_CONFIG" });
+		return res.result;
+	}
+	async setSignerMode(signerMode) {
+		await this.post({
+			type: "PM_SET_SIGNER_MODE",
+			payload: { signerMode }
+		});
+	}
+	async getSignerMode(opts) {
+		const res = await this.post({ type: "PM_GET_SIGNER_MODE" }, opts);
+		return res.result;
+	}
+	async setTheme(theme) {
+		await this.post({
+			type: "PM_SET_THEME",
+			payload: { theme }
+		});
+	}
+	async prefetchBlockheight() {
+		await this.post({ type: "PM_PREFETCH_BLOCKHEIGHT" });
+	}
+	async getRecentLogins() {
+		const res = await this.post({ type: "PM_GET_RECENT_LOGINS" });
+		return res.result;
+	}
+	async setDerivedAddress(payload) {
+		await this.post({
+			type: "PM_SET_DERIVED_ADDRESS",
+			payload
+		});
+	}
+	async getDerivedAddressRecord(payload) {
+		const res = await this.post({
+			type: "PM_GET_DERIVED_ADDRESS_RECORD",
+			payload
+		});
+		return res.result || null;
+	}
+	async getDerivedAddress(payload) {
+		const res = await this.post({
+			type: "PM_GET_DERIVED_ADDRESS",
+			payload
+		});
+		return res.result || null;
+	}
+	async getRecoveryEmails(nearAccountId) {
+		const res = await this.post({
+			type: "PM_GET_RECOVERY_EMAILS",
+			payload: { nearAccountId }
+		});
+		return res.result || [];
+	}
+	async setRecoveryEmails(payload) {
+		const { options } = payload;
+		const safeOptions = {
+			signerMode: this.resolveSignerMode(options.signerMode),
+			waitUntil: options.waitUntil,
+			confirmationConfig: options.confirmationConfig
+		};
+		const res = await this.post({
+			type: "PM_SET_RECOVERY_EMAILS",
+			payload: {
+				nearAccountId: payload.nearAccountId,
+				recoveryEmails: payload.recoveryEmails,
+				options: safeOptions
+			},
+			options: { onProgress: this.wrapOnEvent(options?.onEvent, isActionSSEEvent) }
+		});
+		return res.result;
+	}
+	wrapOnEvent(onEvent, isExpectedEvent) {
+		if (!onEvent) return void 0;
+		return (progress) => {
+			try {
+				if (isExpectedEvent(progress)) onEvent(progress);
+			} catch {}
+		};
+	}
+	async signAndSendTransactions(payload) {
+		const { options } = payload;
+		const safeOptions = {
+			signerMode: this.resolveSignerMode(options.signerMode),
+			waitUntil: options.waitUntil,
+			executionWait: options.executionWait,
+			confirmationConfig: options.confirmationConfig,
+			...options.confirmerText ? { confirmerText: options.confirmerText } : {}
+		};
+		const res = await this.post({
+			type: "PM_SIGN_AND_SEND_TXS",
+			payload: {
+				nearAccountId: payload.nearAccountId,
+				transactions: payload.transactions,
+				options: safeOptions
+			},
+			options: { onProgress: this.wrapOnEvent(options?.onEvent, isActionSSEEvent) }
+		});
+		return res.result;
+	}
+	async hasPasskeyCredential(nearAccountId) {
+		const res = await this.post({
+			type: "PM_HAS_PASSKEY",
+			payload: { nearAccountId }
+		});
+		return !!res?.result;
+	}
+	async viewAccessKeyList(accountId) {
+		const res = await this.post({
+			type: "PM_VIEW_ACCESS_KEYS",
+			payload: { accountId }
+		});
+		return res.result;
+	}
+	async deleteDeviceKey(payload) {
+		const res = await this.post({
+			type: "PM_DELETE_DEVICE_KEY",
+			payload: {
+				accountId: payload.accountId,
+				publicKeyToDelete: payload.publicKeyToDelete,
+				options: { signerMode: this.resolveSignerMode(payload.options.signerMode) }
+			},
+			options: { onProgress: this.wrapOnEvent(payload.options?.onEvent, isActionSSEEvent) }
+		});
+		return res.result;
+	}
+	async sendTransaction(args) {
+		const { options } = args;
+		const safeOptions = options ? { waitUntil: options.waitUntil } : void 0;
+		const res = await this.post({
+			type: "PM_SEND_TRANSACTION",
+			payload: {
+				signedTransaction: args.signedTransaction,
+				options: safeOptions
+			},
+			options: { onProgress: this.wrapOnEvent(options?.onEvent, isActionSSEEvent) }
+		});
+		return res.result;
+	}
+	async exportNearKeypairWithUI(nearAccountId, options) {
+		try {
+			this.showFrameForActivation();
+			const walletOrigin = this.walletOriginOrigin;
+			this.attachExportUiClosedListener(walletOrigin);
+			this.attachExportUiFallbackListener(walletOrigin, nearAccountId);
+			await this.post({
+				type: "PM_EXPORT_NEAR_KEYPAIR_UI",
+				payload: {
+					nearAccountId,
+					variant: options?.variant,
+					theme: options?.theme
+				},
+				options: { sticky: true }
+			});
+			return;
+		} catch (e) {
+			await this.openOfflineExport({ accountId: nearAccountId });
+		}
+	}
+	/**
+	* Open the offline-export route as a full-screen overlay iframe and instruct it via postMessage
+	* to begin the export flow for the given account. Cleans up when the viewer closes or on error.
+	*/
+	async openOfflineExport({ accountId, timeoutMs = 2e4 }) {
+		const walletOrigin = this.opts.walletOrigin || window.location.origin;
+		openOfflineExportWindow({
+			walletOrigin,
+			target: "_blank",
+			accountId
+		});
+		return Promise.resolve();
+	}
+	async syncAccount(payload) {
+		const res = await this.post({
+			type: "PM_SYNC_ACCOUNT_FLOW",
+			payload: { accountId: payload.accountId },
+			options: { onProgress: this.wrapOnEvent(payload.onEvent, isSyncAccountSSEEvent) }
+		});
+		return res.result;
+	}
+	async startEmailRecovery(payload) {
+		const safeOptions = payload.options ? {
+			...payload.options.confirmerText ? { confirmerText: payload.options.confirmerText } : {},
+			...payload.options.confirmationConfig ? { confirmationConfig: payload.options.confirmationConfig } : {}
+		} : void 0;
+		const res = await this.post({
+			type: "PM_START_EMAIL_RECOVERY",
+			payload: {
+				accountId: payload.accountId,
+				options: safeOptions && Object.keys(safeOptions).length > 0 ? safeOptions : void 0
+			},
+			options: { onProgress: this.wrapOnEvent(payload.onEvent, isEmailRecoverySSEEvent) }
+		});
+		return res.result;
+	}
+	async finalizeEmailRecovery(payload) {
+		await this.post({
+			type: "PM_FINALIZE_EMAIL_RECOVERY",
+			payload: {
+				accountId: payload.accountId,
+				nearPublicKey: payload.nearPublicKey
+			},
+			options: { onProgress: this.wrapOnEvent(payload.onEvent, isEmailRecoverySSEEvent) }
+		});
+	}
+	async stopEmailRecovery(payload) {
+		await this.post({
+			type: "PM_STOP_EMAIL_RECOVERY",
+			payload: {
+				accountId: payload?.accountId,
+				nearPublicKey: payload?.nearPublicKey
+			}
+		});
+	}
+	async linkDeviceWithScannedQRData(payload) {
+		this.showFrameForActivation();
+		try {
+			const safeOptions = payload.options ? {
+				...payload.options.confirmationConfig ? { confirmationConfig: payload.options.confirmationConfig } : {},
+				...payload.options.confirmerText ? { confirmerText: payload.options.confirmerText } : {}
+			} : void 0;
+			const res = await this.post({
+				type: "PM_LINK_DEVICE_WITH_SCANNED_QR_DATA",
+				payload: {
+					qrData: payload.qrData,
+					fundingAmount: payload.fundingAmount,
+					options: safeOptions && Object.keys(safeOptions).length > 0 ? safeOptions : void 0
+				},
+				options: { onProgress: this.wrapOnEvent(payload.options?.onEvent, isDeviceLinkingSSEEvent) }
+			});
+			return res.result;
+		} finally {
+			this.hideFrameForActivation();
+		}
+	}
+	async startDevice2LinkingFlow(payload) {
+		if (this.state.device2StartPromise) return this.state.device2StartPromise;
+		const options = payload?.options;
+		const safeOptions = options ? {
+			...options.confirmationConfig ? { confirmationConfig: options.confirmationConfig } : {},
+			...options.confirmerText ? { confirmerText: options.confirmerText } : {}
+		} : void 0;
+		const p = this.post({
+			type: "PM_START_DEVICE2_LINKING_FLOW",
+			payload: {
+				ui: payload?.ui,
+				cameraId: payload?.cameraId,
+				options: safeOptions
+			},
+			options: {
+				onProgress: this.wrapOnEvent(options?.onEvent, isDeviceLinkingSSEEvent),
+				sticky: true
+			}
+		}).then((res) => res.result).finally(() => {
+			this.state.device2StartPromise = null;
+		});
+		this.state.device2StartPromise = p;
+		return p;
+	}
+	async stopDevice2LinkingFlow() {
+		await this.post({ type: "PM_STOP_DEVICE2_LINKING_FLOW" });
+		this.progressBus.clearAll();
+	}
+	async cancelRequest(requestId) {
+		await this.post({
+			type: "PM_CANCEL",
+			payload: { requestId }
+		}).catch(() => {});
+		this.progressBus.unregister(requestId);
+		this.hideFrameForActivation();
+	}
+	async cancelAll() {
+		await this.post({
+			type: "PM_CANCEL",
+			payload: {}
+		}).catch(() => {});
+		this.progressBus.clearAll();
+		this.hideFrameForActivation();
+	}
+	onPortMessage(e) {
+		const msg = e.data;
+		if (msg.type === "PREFERENCES_CHANGED") {
+			const payload = msg.payload;
+			try {
+				this.state.signerModePreference = payload?.signerMode ?? this.state.signerModePreference;
+			} catch {}
+			this.emitPreferencesChanged(payload);
+			return;
+		}
+		const requestId = msg.requestId;
+		if (!requestId) return;
+		if (msg.type === "PROGRESS") {
+			const payload = msg.payload;
+			this.progressBus.dispatch({
+				requestId,
+				payload
+			});
+			const pend = this.state.pending.get(requestId);
+			if (pend) {
+				if (pend.timer) window.clearTimeout(pend.timer);
+				pend.timer = window.setTimeout(() => {
+					const err = pend.onTimeout();
+					pend.reject(err);
+				}, pend.timeoutMs);
+			}
+			return;
+		}
+		const pending = this.state.pending.get(requestId);
+		if (!this.progressBus.isSticky(requestId)) {
+			if (!this.progressBus.wantsVisible()) this.hideFrameForActivation();
+		}
+		if (!pending) {
+			if (this.debug) console.debug("[WalletIframeRouter] Non-PROGRESS without pending → hide + unregister", {
+				requestId,
+				type: msg?.type || "unknown"
+			});
+			this.progressBus.unregister(requestId);
+			return;
+		}
+		this.state.pending.delete(requestId);
+		if (pending.timer) window.clearTimeout(pending.timer);
+		if (msg.type === "ERROR") {
+			const err = new Error(msg.payload?.message || "Wallet error");
+			err.code = msg.payload?.code;
+			err.details = msg.payload?.details;
+			pending.reject(err);
+			this.progressBus.dispatch({
+				requestId,
+				payload: {
+					step: 0,
+					phase: "error",
+					status: "error",
+					message: msg.payload?.message
+				}
+			});
+			this.progressBus.unregister(requestId);
+			return;
+		}
+		pending.resolve(msg.payload);
+		if (!this.progressBus.isSticky(requestId)) this.progressBus.unregister(requestId);
+	}
+	/**
+	* Post a typed envelope over the MessagePort with robust readiness handling.
+	* This is the core method that handles all communication with the iframe.
+	*
+	* Flow:
+	* 1. Ensure iframe is ready (lazy initialization)
+	* 2. Generate unique request ID for correlation
+	* 3. Set up timeout and progress handling
+	* 4. Send message to iframe via MessagePort
+	* 5. Wait for response (PM_RESULT or ERROR)
+	* 6. Clean up on completion or timeout
+	*/
+	async post(envelope, postOpts) {
+		if (!this.state.ready || !this.state.port) await this.init();
+		const requestId = `${Date.now()}-${++this.state.reqCounter}`;
+		const full = {
+			...envelope,
+			requestId
+		};
+		const { options } = full;
+		const timeoutMs = postOpts?.timeoutMs ?? this.opts.requestTimeoutMs;
+		return new Promise((resolve, reject) => {
+			const onTimeout = () => {
+				const pending = this.state.pending.get(requestId);
+				if (pending?.timer !== void 0) window.clearTimeout(pending.timer);
+				this.state.pending.delete(requestId);
+				this.progressBus.unregister(requestId);
+				this.overlayState.controller.setSticky(false);
+				if (!this.progressBus.wantsVisible()) this.hideFrameForActivation();
+				this.sendBestEffortCancel(requestId);
+				return /* @__PURE__ */ new Error(`Wallet request timeout for ${envelope.type}`);
+			};
+			const timer = window.setTimeout(() => {
+				const err = onTimeout();
+				reject(err);
+			}, timeoutMs);
+			this.state.pending.set(requestId, {
+				resolve: (v) => resolve(v),
+				reject,
+				timer,
+				timeoutMs,
+				onProgress: options?.onProgress,
+				onTimeout
+			});
+			this.progressBus.register({
+				requestId,
+				sticky: !!options?.sticky,
+				onProgress: (payload) => {
+					try {
+						options?.onProgress?.(payload);
+					} catch {}
+				}
+			});
+			try {
+				const stickyVal = isObject(options) ? options.sticky : void 0;
+				const wireOptions = isBoolean(stickyVal) ? { sticky: stickyVal } : void 0;
+				const serializableFull = wireOptions ? {
+					...full,
+					options: wireOptions
+				} : {
+					...full,
+					options: void 0
+				};
+				this.overlayState.controller.setSticky(!!(wireOptions && wireOptions.sticky));
+				if (!this.overlayState.controller.getState().visible) {
+					const intent = this.computeOverlayIntent(serializableFull.type);
+					if (intent.mode === "fullscreen") {
+						this.overlayState.controller.setSticky(!!(wireOptions && wireOptions.sticky));
+						this.overlayState.controller.showFullscreen();
+					}
+				}
+				this.state.port.postMessage(serializableFull);
+			} catch (err) {
+				this.state.pending.delete(requestId);
+				window.clearTimeout(timer);
+				this.progressBus.unregister(requestId);
+				reject(toError(err));
+			}
+		});
+	}
+	/**
+	* Preflight overlay decision before sending the request.
+	* - This decides whether to show fullscreen early for user activation.
+	* - ProgressBus handles hide timing; OverlayController just executes the decision.
+	*/
+	computeOverlayIntent(type) {
+		switch (type) {
+			case "PM_EXPORT_NEAR_KEYPAIR_UI":
+			case "PM_REGISTER":
+			case "PM_LOGIN":
+			case "PM_SYNC_ACCOUNT_FLOW":
+			case "PM_LINK_DEVICE_WITH_SCANNED_QR_DATA":
+			case "PM_SIGN_AND_SEND_TXS":
+			case "PM_EXECUTE_ACTION":
+			case "PM_SEND_TRANSACTION":
+			case "PM_SIGN_TXS_WITH_ACTIONS": return { mode: "fullscreen" };
+			default: return { mode: "hidden" };
+		}
+	}
+	showFrameForActivation() {
+		this.transport.ensureIframeMounted();
+		if (this.overlayState.forceFullscreen) this.overlayState.controller.showFullscreen();
+		else this.overlayState.controller.showFullscreen();
+	}
+	hideFrameForActivation() {
+		if (!this.overlayState.controller.getState().visible) return;
+		this.overlayState.controller.hide();
+	}
+	sendBestEffortCancel(targetRequestId) {
+		const port = this.state.port;
+		if (!port) return;
+		const cancelEnvelope = {
+			type: "PM_CANCEL",
+			requestId: `cancel-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+			payload: targetRequestId ? { requestId: targetRequestId } : {}
+		};
+		port.postMessage(cancelEnvelope);
+	}
+	/**
+	* Public toggle to surface the wallet iframe for user activation or hide it.
+	* Useful when mounting inline UI components that require direct user clicks.
+	*/
+	setOverlayVisible(visible) {
+		if (visible) if (this.overlayState.forceFullscreen) this.overlayState.controller.showFullscreen();
+		else this.showFrameForActivation();
+		else this.hideFrameForActivation();
+	}
+	/** Public helper for tests/tools: get the underlying iframe element. */
+	getIframeEl() {
+		return this.transport.getIframeEl();
+	}
+	/** Public helper for tests/tools: inspect current overlay state. */
+	getOverlayState() {
+		return this.overlayState.controller.getState();
+	}
+	/**
+	* Position and show the wallet iframe as an anchored overlay matching a DOMRect.
+	* Accepts viewport-relative coordinates (from getBoundingClientRect()).
+	*
+	* Important: Some apps apply CSS transforms (or filters/perspective) on html/body,
+	* which changes the containing block for position: fixed. In those cases a fixed
+	* iframe will be offset by the page scroll. To avoid that mismatch, anchor the
+	* overlay using absolute positioning in document coordinates.
+	*/
+	setOverlayBounds(rect) {
+		if (this.overlayState.forceFullscreen) return;
+		this.transport.ensureIframeMounted();
+		this.overlayState.controller.showAnchored(rect);
+	}
+	postWindowMessage(w, data, target) {
+		try {
+			w.postMessage(data, target);
+		} catch (err) {
+			if (this.debug) console.error("[WalletIframeRouter] window.postMessage failed", {
+				error: err,
+				data
+			});
+		}
+	}
+};
+const REGISTRATION_PHASES = new Set(Object.values(RegistrationPhase));
+const LOGIN_PHASES = new Set(Object.values(LoginPhase));
+const ACTION_PHASES = new Set(Object.values(ActionPhase));
+const DEVICE_LINKING_PHASES = new Set(Object.values(DeviceLinkingPhase));
+const SYNC_ACCOUNT_PHASES = new Set(Object.values(SyncAccountPhase));
+const EMAIL_RECOVERY_PHASES = new Set(Object.values(EmailRecoveryPhase));
+function phaseOf(progress) {
+	return String(progress?.phase ?? "");
+}
+function isRegistrationSSEEvent(progress) {
+	return REGISTRATION_PHASES.has(phaseOf(progress));
+}
+function isLoginSSEEvent(p) {
+	return LOGIN_PHASES.has(phaseOf(p));
+}
+function isActionSSEEvent(p) {
+	return ACTION_PHASES.has(phaseOf(p));
+}
+function isDeviceLinkingSSEEvent(p) {
+	return DEVICE_LINKING_PHASES.has(phaseOf(p));
+}
+function isSyncAccountSSEEvent(p) {
+	return SYNC_ACCOUNT_PHASES.has(phaseOf(p));
+}
+function isEmailRecoverySSEEvent(p) {
+	return EMAIL_RECOVERY_PHASES.has(phaseOf(p));
+}
+/**
+* Strips out class functions as they cannot be sent over postMessage to iframe
+*/
+function normalizeSignedTransactionObject(result) {
+	const arr = Array.isArray(result) ? result : [];
+	const normalized = arr.map((entry) => {
+		if (entry?.signedTransaction) {
+			const st = entry.signedTransaction;
+			if (isPlainSignedTransactionLike(st)) entry.signedTransaction = SignedTransaction.fromPlain({
+				transaction: st.transaction,
+				signature: st.signature,
+				borsh_bytes: extractBorshBytesFromPlainSignedTx(st)
+			});
+		}
+		return entry;
+	});
+	return normalized;
+}
+function removeFunctionsFromOptions(options) {
+	return stripFunctionsShallow(options);
+}
+
+//#endregion
+export { WalletIframeRouter };