@seams/wallet 0.17.0 → 0.19.0

package/dist/esm/SeamsWeb/walletIframe/host/ui/auth-menu/icons.js

@@ -39,6 +39,42 @@ function passkeyRingIcon() {
 		})]
 	});
 }
+/** The passkey ring as it closes and fills behind a check. */
+function passkeySuccessIcon() {
+	return /* @__PURE__ */ jsxs("svg", {
+		class: "seams-success-ring",
+		viewBox: "0 0 56 56",
+		fill: "none",
+		"aria-hidden": "true",
+		focusable: "false",
+		children: [
+			/* @__PURE__ */ jsx("circle", {
+				class: "seams-passkey-ring-track",
+				cx: "28",
+				cy: "28",
+				r: "26.75"
+			}),
+			/* @__PURE__ */ jsx("circle", {
+				class: "seams-success-ring-arc",
+				cx: "28",
+				cy: "28",
+				r: "26.75",
+				pathLength: "100"
+			}),
+			/* @__PURE__ */ jsx("circle", {
+				class: "seams-success-ring-seal",
+				cx: "28",
+				cy: "28",
+				r: "28"
+			}),
+			/* @__PURE__ */ jsx("path", {
+				class: "seams-success-ring-check",
+				d: "M36.7 21.5 24.75 33.4l-5.4-5.4",
+				pathLength: "1"
+			})
+		]
+	});
+}
 function accountDropdownIcon() {
 	return /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx("svg", {
 		class: "seams-account-dropdown-arrow",
@@ -153,6 +189,6 @@ function alertIcon() {
 	}));
 }
 //#endregion
-export { accountDropdownIcon, alertIcon, backIcon, chevronIcon, fingerprintIcon, googleIcon, linkDeviceIcon, linkFailedIcon, mailIcon, passkeyRingIcon, recoveryIcon, rerollIcon, shieldIcon };
+export { accountDropdownIcon, alertIcon, backIcon, chevronIcon, fingerprintIcon, googleIcon, linkDeviceIcon, linkFailedIcon, mailIcon, passkeyRingIcon, passkeySuccessIcon, recoveryIcon, rerollIcon, shieldIcon };
 
 //# sourceMappingURL=icons.js.map

package/dist/esm/SeamsWeb/walletIframe/host/ui/auth-menu/mountAuthMenuSurface.js

@@ -1,5 +1,6 @@
 import { appearanceTokenCssRule } from "../../../../../core/signingEngine/uiConfirm/ui/appearance-token-vars.js";
 import { createCspStylesheetManager, getDefaultCspNonce } from "../../../../../core/browser/walletIframe/csp-stylesheet.js";
+import { withWalletLocale } from "../../../../../core/signingEngine/uiConfirm/ui/preact/WalletLocale.js";
 import { AuthMenuSurface } from "./AuthMenuSurface.js";
 import { render } from "preact";
 import { jsx } from "preact/jsx-runtime";
@@ -45,14 +46,15 @@ var MountedAuthMenuSurface = class {
 	}
 	update(viewModel) {
 		if (this.state.kind === "disposed") return;
+		this.element.lang = viewModel.appearance.locale ?? "en";
 		this.element.dataset.theme = viewModel.appearance.theme.mode;
 		this.styles.setDynamicRule(this.element.id + "-appearance", appearanceTokenCssRule(this.element.id, viewModel.appearance));
-		render(/* @__PURE__ */ jsx(AuthMenuSurface, {
+		render(withWalletLocale(viewModel.appearance.locale ?? "en", /* @__PURE__ */ jsx(AuthMenuSurface, {
 			element: this.element,
 			viewModel,
 			onIntent: this.state.onIntent,
 			styles: this.styles
-		}), this.element);
+		})), this.element);
 	}
 	dispose() {
 		if (this.state.kind === "disposed") return;

package/dist/esm/SeamsWeb/walletIframe/host/ui/auth-menu/presentation.js

@@ -0,0 +1,117 @@
+import { demoEmailOtpCodeFromDelivery } from "../../../../../core/signingEngine/session/emailOtp/challengeDelivery.js";
+import { WalletText } from "../../../../../core/signingEngine/uiConfirm/ui/preact/WalletLocale.js";
+import { resolveAuthMenuLoginAccount } from "../../auth-menu/domain.js";
+import { Fragment, jsx, jsxs } from "preact/jsx-runtime";
+//#region src/SeamsWeb/walletIframe/host/ui/auth-menu/presentation.tsx
+function renderDemoEmailCode(delivery) {
+	const code = demoEmailOtpCodeFromDelivery(delivery);
+	if (code === null) return null;
+	return /* @__PURE__ */ jsxs("p", {
+		class: "seams-otp-description",
+		children: [
+			/* @__PURE__ */ jsx(WalletText, { message: "Demo email code:" }),
+			" ",
+			/* @__PURE__ */ jsx("code", { children: code })
+		]
+	});
+}
+const AUTH_MENU_TITLE_ID = "seams-auth-menu-title";
+const AUTH_MENU_ACCOUNT_LIST_ID = "seams-auth-menu-account-list";
+function otpCodeDigits(code, length = 6) {
+	return code.padEnd(length, " ").slice(0, length).split("");
+}
+function recoveryCaretAtPoint(root, clientX, clientY, codeLength) {
+	let nearest = null;
+	for (const slot of root.querySelectorAll("[data-recovery-slot]")) {
+		const index = Number(slot.dataset.recoverySlot);
+		const box = slot.getBoundingClientRect();
+		const dx = clientX < box.left ? box.left - clientX : Math.max(0, clientX - box.right);
+		const dy = clientY < box.top ? box.top - clientY : Math.max(0, clientY - box.bottom);
+		const distance = dx * dx + dy * dy;
+		if (nearest === null || distance < nearest.distance) nearest = {
+			index,
+			distance,
+			after: clientX > box.left + box.width / 2
+		};
+	}
+	if (nearest === null) return null;
+	return Math.min(nearest.after ? nearest.index + 1 : nearest.index, codeLength);
+}
+function renderOtpCodeDigit(digit) {
+	return /* @__PURE__ */ jsx(Fragment, { children: /* @__PURE__ */ jsx("span", {
+		class: `seams-otp-slot ${digit.trim() ? "is-filled" : ""}`,
+		children: digit
+	}) });
+}
+function authViewKey(viewModel) {
+	const stage = viewModel.kind === "recovery" ? `:${viewModel.stage}` : "";
+	return `${viewModel.kind}:${viewModel.mode}:${viewModel.status.kind}${stage}`;
+}
+function recoveryAnnouncement(viewModel) {
+	if (viewModel.status.kind === "succeeded") return "";
+	if (viewModel.status.kind === "busy") return viewModel.status.headline;
+	if (viewModel.status.kind === "recoverable") return viewModel.status.message;
+	if (viewModel.stage === "passkey_ready") return "Recovery code accepted.";
+	if (viewModel.stage === "sign_in_ready") return "Wallet recovered. Unlock it to continue.";
+	return "";
+}
+function recoveryBackLabel(viewModel) {
+	if (viewModel.kind !== "recovery") return "Back";
+	return viewModel.stage === "choose_method" ? "Back to recovery code" : "Back to unlock wallet";
+}
+function recoveryNavigationLocked(viewModel) {
+	return viewModel.kind === "recovery" && viewModel.stage === "finalizing";
+}
+function modeSwitchCopy(mode) {
+	return mode === "register" ? {
+		prompt: "Already have a wallet?",
+		action: "Unlock wallet",
+		nextMode: "login"
+	} : {
+		prompt: "Don't have a wallet?",
+		action: "Create a wallet",
+		nextMode: "register"
+	};
+}
+function modeLabel(mode) {
+	return mode === "register" ? "Create a wallet" : "Unlock wallet";
+}
+function passkeyButtonLabel(mode) {
+	return mode === "register" ? "Create wallet with passkey" : "Unlock with passkey";
+}
+/** The failure the footer strip reports. Only the menu itself reports there. */
+function menuNotice(viewModel) {
+	if (viewModel.kind === "google_otp_login" || viewModel.kind === "google_registration") return viewModel.error || null;
+	return viewModel.kind === "passkey" && viewModel.status.kind === "recoverable" && viewModel.status.reason === "error" ? viewModel.status.message : null;
+}
+function selectedLoginAccount(viewModel) {
+	return resolveAuthMenuLoginAccount(viewModel.accountOptions, viewModel.selectedAccount).selectedAccount;
+}
+function selectedAccountPrimaryText(account) {
+	return account.walletId;
+}
+function accountSecondaryText(account) {
+	return account.authMethod === "email_otp" ? account.emailAddress : null;
+}
+function savedAccountsTriggerLabel(account) {
+	if (!account) return "Saved wallets";
+	const emailAddress = accountSecondaryText(account);
+	return emailAddress ? `Saved wallets. Selected wallet ID ${account.walletId}, email ${emailAddress}` : `Saved wallets. Selected ${account.walletId}`;
+}
+function accountGroups(options) {
+	const passkeyAccounts = options.filter((option) => option.authMethod === "passkey");
+	const emailOtpAccounts = options.filter((option) => option.authMethod === "email_otp");
+	return [{
+		authMethod: "passkey",
+		label: "Passkey",
+		accounts: passkeyAccounts
+	}, {
+		authMethod: "email_otp",
+		label: "Email OTP",
+		accounts: emailOtpAccounts
+	}].filter((group) => group.accounts.length > 0);
+}
+//#endregion
+export { AUTH_MENU_ACCOUNT_LIST_ID, AUTH_MENU_TITLE_ID, accountGroups, accountSecondaryText, authViewKey, menuNotice, modeLabel, modeSwitchCopy, otpCodeDigits, passkeyButtonLabel, recoveryAnnouncement, recoveryBackLabel, recoveryCaretAtPoint, recoveryNavigationLocked, renderDemoEmailCode, renderOtpCodeDigit, savedAccountsTriggerLabel, selectedAccountPrimaryText, selectedLoginAccount };
+
+//# sourceMappingURL=presentation.js.map

package/dist/esm/SeamsWeb/walletIframe/host/ui/auth-menu/recovery-code-input.js

@@ -0,0 +1,60 @@
+import { EMAIL_OTP_RECOVERY_KEY_ALPHABET } from "../../../../../shared-ts/src/utils/emailOtpRecoveryKey.js";
+import "../../../../../shared-ts/src/wallet-recovery/recoveryCodes.js";
+import { jsx } from "preact/jsx-runtime";
+//#region src/SeamsWeb/walletIframe/host/ui/auth-menu/recovery-code-input.tsx
+const RECOVERY_CODE_CHARACTERS = new Set(EMAIL_OTP_RECOVERY_KEY_ALPHABET);
+function recoveryInputCharacters(code) {
+	let characters = "";
+	for (const character of code.toUpperCase()) {
+		const read = character === "O" ? "0" : character === "I" || character === "L" ? "1" : character;
+		if (RECOVERY_CODE_CHARACTERS.has(read)) characters += read;
+	}
+	return characters;
+}
+const RECOVERY_CODE_SEPARATOR = /[\s\-\u2010-\u2015\u2212]/;
+/** Characters the input dropped because no recovery code contains them, such as U. */
+function rejectedRecoveryCharacters(input) {
+	const rejected = /* @__PURE__ */ new Set();
+	for (const character of input.toUpperCase()) {
+		if (RECOVERY_CODE_SEPARATOR.test(character)) continue;
+		if (recoveryInputCharacters(character)) continue;
+		rejected.add(character);
+	}
+	return Array.from(rejected).slice(0, 3);
+}
+function renderRecoveryCodeGroups(code, selection, arrival) {
+	const caret = selection && selection.start === selection.end ? selection.start : null;
+	const lastIndex = 31;
+	const focusIndex = selection === null ? null : Math.min(selection.start, lastIndex);
+	const groups = [];
+	for (let start = 0; start < 32; start += 4) {
+		const end = start + 4;
+		const slots = [];
+		for (let index = start; index < end; index += 1) {
+			const character = code[index] ?? "";
+			const classes = ["seams-otp-slot"];
+			if (character) classes.push("is-filled");
+			if (index === caret) classes.push("is-caret");
+			if (caret === 32 && index === lastIndex) classes.push("is-caret-after");
+			if (selection && index >= selection.start && index < selection.end) classes.push("is-selected");
+			if (arrival && index >= arrival.start && index < arrival.end) classes.push("is-new");
+			slots.push(/* @__PURE__ */ jsx("span", {
+				class: classes.join(" "),
+				"data-recovery-slot": index,
+				children: character
+			}, index));
+		}
+		const groupClasses = ["seams-recovery-code-group"];
+		if (focusIndex !== null && focusIndex >= start && focusIndex < end) groupClasses.push("is-active");
+		if (code.length >= end) groupClasses.push("is-complete");
+		groups.push(/* @__PURE__ */ jsx("div", {
+			class: groupClasses.join(" "),
+			children: slots
+		}, start));
+	}
+	return groups;
+}
+//#endregion
+export { recoveryInputCharacters, rejectedRecoveryCharacters, renderRecoveryCodeGroups };
+
+//# sourceMappingURL=recovery-code-input.js.map

package/dist/esm/SeamsWeb/walletIframe/shared/facadeBoundary.js

@@ -1,4 +1,5 @@
 import { parseMpcMaterialActivationRef } from "../../../shared-ts/src/utils/domainIds.js";
+import { normalizeWalletLocale } from "../../../core/ui/locale.js";
 import { resolveAppearanceTheme, resolveThemePalette } from "../../../core/config/configHelpers.js";
 import { nearAccountRefFromAccountId, thresholdEcdsaChainTargetFromRequest, thresholdEcdsaChainTargetsEqual, walletSessionRefFromSession } from "../../../core/signingEngine/interfaces/ecdsaChainTarget.js";
 import { parseExactEcdsaSigningLaneIdentity, parseExactEd25519ExportMaterialIdentity } from "../../../core/signingEngine/session/identity/exactSigningLaneIdentity.js";
@@ -72,6 +73,7 @@ function normalizeExportKeypairWithUIInput(input, theme) {
 function resolveRuntimeAppearance(current, input) {
 	const rawInput = input;
 	return {
+		locale: normalizeWalletLocale(rawInput.locale ?? current.locale),
 		theme: resolveAppearanceTheme({
 			value: rawInput.theme,
 			fallback: current.theme,

package/dist/esm/core/browser/walletIframe/events.js

@@ -0,0 +1,6 @@
+//#region src/core/browser/walletIframe/events.ts
+const WalletIframeDomEvents = { TX_CONFIRMER_CANCEL: "seams:tx-confirmer-cancel" };
+//#endregion
+export { WalletIframeDomEvents };
+
+//# sourceMappingURL=events.js.map

package/dist/esm/core/config/configBuilder.js

@@ -1,4 +1,5 @@
 import { normalizeTrimmedString } from "../../shared-ts/src/utils/normalize.js";
+import { normalizeWalletLocale } from "../ui/locale.js";
 import { copyEcdsaSignerProvisioningDefaults, resolveAppearanceTheme, resolveBoolean, resolveChains, resolveIntegerInRange, resolveThemePalette } from "./configHelpers.js";
 import { normalizeWalletHostVariant } from "../browser/walletIframe/hostVariant.js";
 import { SIGNING_SESSION_SEAL_ALG, SIGNING_SESSION_SEAL_GROUP_ID } from "../../shared-ts/src/utils/signingSessionSeal.js";
@@ -208,6 +209,7 @@ function buildConfigsFromDefaults(args) {
 			}
 		},
 		ui: { appearance: {
+			locale: normalizeWalletLocale(rawAppearance?.locale ?? defaults.ui.appearance.locale),
 			theme: appearanceTheme,
 			palette: appearancePalette
 		} }

package/dist/esm/core/signingEngine/uiConfirm/ui/appearance.js

@@ -0,0 +1,27 @@
+//#region src/core/signingEngine/uiConfirm/ui/appearance.ts
+const DEFAULT_UI_APPEARANCE = {
+	theme: {
+		id: "default",
+		mode: "dark",
+		colors: {}
+	},
+	palette: "default"
+};
+function isThemeMode(value) {
+	return value === "light" || value === "dark";
+}
+function resolveUiAppearance(args) {
+	const appearance = args.requestedAppearance ?? args.getAppearance?.() ?? DEFAULT_UI_APPEARANCE;
+	if (!isThemeMode(args.requestedMode) || args.requestedMode === appearance.theme.mode) return appearance;
+	return {
+		...appearance,
+		theme: {
+			...appearance.theme,
+			mode: args.requestedMode
+		}
+	};
+}
+//#endregion
+export { resolveUiAppearance };
+
+//# sourceMappingURL=appearance.js.map

package/dist/esm/core/signingEngine/uiConfirm/ui/export-private-key-reveal.js

@@ -0,0 +1,155 @@
+//#region src/core/signingEngine/uiConfirm/ui/export-private-key-reveal.ts
+const HEX_REEL_ALPHABET = "0123456789abcdef";
+const BASE58_REEL_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+const REEL_GLYPH_MIN_HOLD_MS = 90;
+const REEL_GLYPH_MAX_HOLD_MS = 150;
+const REEL_SETTLE_HOLD_EXTENSION_MS = 90;
+const REEL_SETTLE_STAGGER_MS = 700;
+const REEL_SETTLE_SPIN_MS = 300;
+function assertNever(value) {
+	throw new Error(`Unexpected private key reveal state: ${String(value)}`);
+}
+function reelDefinition(scheme) {
+	switch (scheme) {
+		case "secp256k1": return {
+			prefix: "0x",
+			alphabet: HEX_REEL_ALPHABET,
+			slotCount: 64
+		};
+		case "ed25519": return {
+			prefix: "ed25519:",
+			alphabet: BASE58_REEL_ALPHABET,
+			slotCount: 88
+		};
+		default: return assertNever(scheme);
+	}
+}
+function randomReelGlyph(alphabet) {
+	return alphabet[Math.floor(Math.random() * alphabet.length)] ?? alphabet[0] ?? "x";
+}
+function randomGlyphHoldMs(minimumMs, maximumMs) {
+	return minimumMs + Math.random() * (maximumMs - minimumMs);
+}
+function createReelSlots(definition, reducedMotion, now) {
+	const slots = [];
+	for (let index = 0; index < definition.slotCount; index += 1) slots.push({
+		glyph: reducedMotion ? "x" : randomReelGlyph(definition.alphabet),
+		nextChangeAtMs: reducedMotion ? Number.POSITIVE_INFINITY : now + index * 37 % 90
+	});
+	return slots;
+}
+function createSpinningState(entryKey, scheme, reducedMotion, now) {
+	const definition = reelDefinition(scheme);
+	return {
+		kind: "spinning",
+		entryKey,
+		prefix: definition.prefix,
+		alphabet: definition.alphabet,
+		slots: createReelSlots(definition, reducedMotion, now)
+	};
+}
+function maskedPrivateKey(privateKey) {
+	if (!privateKey) return "";
+	const visibleStartLength = (privateKey.startsWith("ed25519:") ? 8 : 0) + 6;
+	const hiddenEnd = Math.max(visibleStartLength, privateKey.length - 6);
+	return `${privateKey.slice(0, visibleStartLength)}${"x".repeat(hiddenEnd - visibleStartLength)}${privateKey.slice(hiddenEnd)}`;
+}
+function settlingState(state, maskedTarget, startedAtMs) {
+	const prefix = maskedTarget.startsWith(state.prefix) ? state.prefix : "";
+	const targetSlots = Array.from(maskedTarget.slice(prefix.length));
+	const slots = targetSlots.length === state.slots.length ? state.slots : targetSlots.map((_, index) => ({
+		glyph: randomReelGlyph(state.alphabet),
+		nextChangeAtMs: startedAtMs + index * 37 % 90
+	}));
+	return {
+		kind: "settling",
+		entryKey: state.entryKey,
+		prefix,
+		alphabet: state.alphabet,
+		slots,
+		targetSlots,
+		lockedSlots: 0,
+		startedAtMs
+	};
+}
+function lockedSlotCount(state, now) {
+	const lastIndex = Math.max(1, state.targetSlots.length - 1);
+	let count = 0;
+	for (let index = 0; index < state.targetSlots.length; index += 1) {
+		const stagger = index / lastIndex * REEL_SETTLE_STAGGER_MS;
+		if (now >= state.startedAtMs + stagger + REEL_SETTLE_SPIN_MS) count += 1;
+	}
+	return count;
+}
+function settlingProgress(state, index, now) {
+	const stagger = index / Math.max(1, state.targetSlots.length - 1) * REEL_SETTLE_STAGGER_MS;
+	const slotStartedAtMs = state.startedAtMs + stagger;
+	return Math.max(0, Math.min(1, (now - slotStartedAtMs) / REEL_SETTLE_SPIN_MS));
+}
+function cycleSpinningSlots(slots, alphabet, now) {
+	let nextSlots = null;
+	for (let index = 0; index < slots.length; index += 1) {
+		const slot = slots[index];
+		if (!slot || now < slot.nextChangeAtMs) continue;
+		if (nextSlots === null) nextSlots = [...slots];
+		nextSlots[index] = {
+			glyph: randomReelGlyph(alphabet),
+			nextChangeAtMs: now + randomGlyphHoldMs(REEL_GLYPH_MIN_HOLD_MS, REEL_GLYPH_MAX_HOLD_MS)
+		};
+	}
+	return nextSlots ?? slots;
+}
+function cycleSettlingSlots(state, lockedSlots, now) {
+	let nextSlots = null;
+	for (let index = 0; index < state.slots.length; index += 1) {
+		const slot = state.slots[index];
+		if (!slot) continue;
+		if (index < lockedSlots) {
+			const targetGlyph = state.targetSlots[index] ?? slot.glyph;
+			if (slot.glyph === targetGlyph && slot.nextChangeAtMs === Number.POSITIVE_INFINITY) continue;
+			if (nextSlots === null) nextSlots = [...state.slots];
+			nextSlots[index] = {
+				glyph: targetGlyph,
+				nextChangeAtMs: Number.POSITIVE_INFINITY
+			};
+			continue;
+		}
+		if (now < slot.nextChangeAtMs) continue;
+		const holdExtensionMs = settlingProgress(state, index, now) * REEL_SETTLE_HOLD_EXTENSION_MS;
+		if (nextSlots === null) nextSlots = [...state.slots];
+		nextSlots[index] = {
+			glyph: randomReelGlyph(state.alphabet),
+			nextChangeAtMs: now + randomGlyphHoldMs(REEL_GLYPH_MIN_HOLD_MS + holdExtensionMs, REEL_GLYPH_MAX_HOLD_MS + holdExtensionMs)
+		};
+	}
+	return nextSlots ?? state.slots;
+}
+function advanceRevealState(state, now) {
+	if (state.kind === "spinning") {
+		const slots = cycleSpinningSlots(state.slots, state.alphabet, now);
+		if (slots === state.slots) return state;
+		return {
+			...state,
+			slots
+		};
+	}
+	if (state.kind === "settling") {
+		const nextLockedSlots = lockedSlotCount(state, now);
+		if (nextLockedSlots >= state.targetSlots.length) return {
+			kind: "settled",
+			entryKey: state.entryKey
+		};
+		const slots = cycleSettlingSlots(state, nextLockedSlots, now);
+		if (slots === state.slots && nextLockedSlots === state.lockedSlots) return state;
+		return {
+			...state,
+			slots,
+			lockedSlots: nextLockedSlots
+		};
+	}
+	return assertNever(state);
+}
+//#endregion
+export { advanceRevealState, createSpinningState, maskedPrivateKey, settlingState };
+
+//# sourceMappingURL=export-private-key-reveal.js.map

package/dist/esm/core/signingEngine/uiConfirm/ui/export-viewer-host.js

@@ -0,0 +1,209 @@
+import { createWalletIframeSurfaceMeasurementReporter } from "../../../../SeamsWeb/walletIframe/host/surface-measurement-reporter.js";
+import { sameSurfaceMeasurementBinding } from "./surface-measurement-binding.js";
+import { resolveUiAppearance } from "./appearance.js";
+//#region src/core/signingEngine/uiConfirm/ui/export-viewer-host.ts
+let mountedHost = null;
+let mountVersion = 0;
+var ExportViewerHost = class {
+	surface;
+	state;
+	constructor(session, context, model, binding, lifecycle, mount) {
+		this.session = session;
+		this.context = context;
+		this.state = {
+			kind: "mounted",
+			lifecycle,
+			binding,
+			reporter: null
+		};
+		this.surface = mount({
+			parent: document.body,
+			context,
+			model,
+			onClosed: this.closed
+		});
+	}
+	start() {
+		if (this.state.kind === "disposed") return;
+		notifyLifecycle(this.state.lifecycle, "opened");
+		if (this.state.kind === "mounted") this.bindMeasurement(this.state.binding);
+	}
+	matches(session, context) {
+		return this.surface.element.isConnected && this.context === context && this.session.kind === session.kind && this.session.id === session.id;
+	}
+	update(model, binding, lifecycle) {
+		if (this.state.kind === "disposed") return;
+		if (lifecycle) this.state.lifecycle = lifecycle;
+		this.surface.update(model);
+		if (!sameSurfaceMeasurementBinding(this.state.binding, binding)) this.bindMeasurement(binding);
+	}
+	dispose() {
+		if (mountedHost === this) mountedHost = null;
+		this.surface.dispose();
+	}
+	closed = () => {
+		const state = this.state;
+		if (state.kind === "disposed") return;
+		this.state = { kind: "disposed" };
+		if (mountedHost === this) {
+			mountedHost = null;
+			mountVersion += 1;
+		}
+		state.reporter?.disconnect();
+		notifyLifecycle(state.lifecycle, "closed");
+	};
+	bindMeasurement(binding) {
+		const state = this.state;
+		if (state.kind === "disposed") return;
+		state.reporter?.disconnect();
+		state.binding = binding;
+		state.reporter = null;
+		if (binding.kind === "disabled") return;
+		const reporter = createWalletIframeSurfaceMeasurementReporter({
+			kind: "request_surface",
+			element: this.surface.element,
+			requestId: binding.requestId,
+			postMeasurement: binding.postMeasurement
+		});
+		if (this.state === state) state.reporter = reporter;
+		else reporter.disconnect();
+	}
+};
+function notifyLifecycle(listener, event) {
+	try {
+		listener?.(event);
+	} catch {}
+}
+function exportContext(args) {
+	const binding = args.surfaceMeasurementBinding;
+	if (binding.kind !== "wallet_iframe") return "standalone";
+	return (binding.hostSurfaceVariant ?? args.variant) === "modal" ? "wallet-iframe" : "standalone";
+}
+function normalizeGuidance(guidance) {
+	if (!guidance) return void 0;
+	const title = guidance.title.trim();
+	const body = guidance.body?.trim();
+	const steps = guidance.steps?.map(trimText).filter(nonemptyText);
+	if (!title && !body && !steps?.length) return void 0;
+	return {
+		title,
+		body,
+		steps
+	};
+}
+function trimText(value) {
+	return value.trim();
+}
+function nonemptyText(value) {
+	return value.length > 0;
+}
+function hasKey(entry) {
+	return !!entry.publicKey.trim() || !!entry.privateKey.trim();
+}
+function keyMetadata(entry, index) {
+	return {
+		id: `${entry.scheme}-${index}`,
+		scheme: entry.scheme,
+		label: entry.label.trim(),
+		publicKey: entry.publicKey.trim(),
+		address: entry.address?.trim() ?? ""
+	};
+}
+function normalizeExportContent(args) {
+	const accountId = args.accountId.trim();
+	const guidance = normalizeGuidance(args.guidance);
+	const message = args.errorMessage?.trim();
+	if (message) return {
+		kind: "failed",
+		accountId,
+		guidance,
+		message
+	};
+	const entries = args.keys?.filter(hasKey) ?? [];
+	if (entries.length === 0) {
+		const publicKey = args.publicKey?.trim() ?? "";
+		const privateKey = args.privateKey?.trim() ?? "";
+		if (publicKey || privateKey) entries.push({
+			scheme: "ed25519",
+			label: "NEAR Ed25519",
+			publicKey,
+			privateKey
+		});
+	}
+	if (args.loading) {
+		const loading = {
+			kind: "loading",
+			accountId,
+			guidance,
+			entries: []
+		};
+		for (const [index, entry] of entries.entries()) loading.entries.push({
+			...keyMetadata(entry, index),
+			material: { kind: "loading" }
+		});
+		return loading;
+	}
+	const ready = {
+		kind: "ready",
+		accountId,
+		guidance,
+		entries: []
+	};
+	for (const [index, entry] of entries.entries()) {
+		const privateKey = entry.privateKey.trim();
+		ready.entries.push({
+			...keyMetadata(entry, index),
+			material: privateKey ? {
+				kind: "ready",
+				value: privateKey
+			} : { kind: "unavailable" }
+		});
+	}
+	return ready;
+}
+function isExportViewerSessionOpen(sessionId) {
+	const id = sessionId.trim();
+	return !!id && mountedHost?.session.kind === "tracked" && mountedHost.session.id === id && mountedHost.surface.element.isConnected;
+}
+async function upsertExportViewerHost(args) {
+	if (typeof document === "undefined") throw new Error("Export viewer host requires a DOM environment");
+	const version = ++mountVersion;
+	const model = {
+		variant: args.variant,
+		appearance: resolveUiAppearance({
+			requestedAppearance: args.appearance,
+			requestedMode: args.theme
+		}),
+		content: normalizeExportContent(args)
+	};
+	const id = args.sessionId?.trim();
+	const session = id ? {
+		kind: "tracked",
+		id
+	} : { kind: "untracked" };
+	const context = exportContext(args);
+	const { mountExportPrivateKeySurface } = await import("./preact/mountExportPrivateKeySurface.js");
+	if (version !== mountVersion) return;
+	if (mountedHost?.matches(session, context)) {
+		mountedHost.update(model, args.surfaceMeasurementBinding, args.onLifecycle);
+		return;
+	}
+	mountedHost?.dispose();
+	if (version !== mountVersion) return;
+	const host = new ExportViewerHost(session, context, model, args.surfaceMeasurementBinding, args.onLifecycle ?? null, mountExportPrivateKeySurface);
+	mountedHost = host;
+	try {
+		host.start();
+	} catch (error) {
+		host.dispose();
+		throw error;
+	}
+}
+function removeExportViewerHostIfPresent() {
+	mountVersion += 1;
+	mountedHost?.dispose();
+}
+//#endregion
+export { isExportViewerSessionOpen, removeExportViewerHostIfPresent, upsertExportViewerHost };
+
+//# sourceMappingURL=export-viewer-host.js.map