@tatchi-xyz/sdk 0.21.0 → 0.31.0

package/dist/esm/sdk/overlay-Ci2FOQKE.js

@@ -0,0 +1,433 @@
+import { isFunction } from "./validation-BTq6LGPp.js";
+import { DEFAULT_WAIT_STATUS } from "./rpc-Dq3ioE9T.js";
+import { base64Decode, base64Encode } from "./base64-dqpWgddX.js";
+import { errorMessage } from "./errors-DevlT39D.js";
+
+//#region src/core/NearRpcError.ts
+function isObj(v) {
+	return !!v && typeof v === "object" && !Array.isArray(v);
+}
+function firstKey(o) {
+	if (!o) return void 0;
+	const keys = Object.keys(o);
+	return keys.length ? keys[0] : void 0;
+}
+var NearRpcError = class NearRpcError extends Error {
+	code;
+	type;
+	kind;
+	index;
+	short;
+	details;
+	operation;
+	constructor(params) {
+		super(params.message);
+		this.name = params.name || "NearRpcError";
+		this.code = params.code;
+		this.type = params.type || "Unknown";
+		this.kind = params.kind;
+		this.index = params.index;
+		this.short = params.short;
+		this.details = params.details;
+		this.operation = params.operation;
+	}
+	static fromRpcResponse(operationName, rpc) {
+		const err = rpc.error || {};
+		const details = err.data;
+		const { message, type, kind, index, short } = describeDetails(operationName, details);
+		return new NearRpcError({
+			message: message || err.message || `${operationName} RPC error`,
+			short: short || kind || "RPC error",
+			type: type || "RpcError",
+			kind,
+			index,
+			code: err.code,
+			name: err.name || "NearRpcError",
+			operation: operationName,
+			details
+		});
+	}
+	static fromOutcome(operationName, outcome, failure) {
+		const { message, type, kind, index, short } = describeFailure(operationName, failure);
+		return new NearRpcError({
+			message: message || `${operationName} failed`,
+			short: short || kind || "TxExecutionError",
+			type: type || "Failure",
+			kind,
+			index,
+			name: "TxExecutionFailure",
+			operation: operationName,
+			details: {
+				Failure: failure,
+				outcome
+			}
+		});
+	}
+};
+function describeDetails(operationName, details) {
+	const d = isObj(details) ? details : void 0;
+	const txExec = isObj(d?.TxExecutionError) ? d.TxExecutionError : void 0;
+	if (!txExec) {
+		const dataStr = d ? ` Details: ${JSON.stringify(d)}` : "";
+		return { message: `${operationName} RPC error.${dataStr}` };
+	}
+	return describeTxExecution(operationName, txExec);
+}
+function describeFailure(operationName, failure) {
+	const f = isObj(failure) ? failure : void 0;
+	if (!f) return { message: `${operationName} failed (Unknown Failure)` };
+	return describeTxExecution(operationName, f);
+}
+function describeTxExecution(operationName, exec) {
+	if (isObj(exec.InvalidTxError)) {
+		const inv = exec.InvalidTxError;
+		let kind = firstKey(inv) || "InvalidTxError";
+		if (isObj(inv.ActionsValidation)) kind = `ActionsValidation.${firstKey(inv.ActionsValidation)}`;
+		const short = kind.startsWith("ActionsValidation.") ? `InvalidTxError: ${kind.split(".")[1] || "ActionsValidation"}` : `InvalidTxError: ${kind}`;
+		return {
+			message: `${operationName} failed (InvalidTxError: ${kind})`,
+			type: "InvalidTxError",
+			kind,
+			short
+		};
+	}
+	if (isObj(exec.ActionError)) {
+		const ae = exec.ActionError;
+		const idx = typeof ae.index === "number" ? ae.index : void 0;
+		const kobj = isObj(ae.kind) ? ae.kind : void 0;
+		const kind = firstKey(kobj) || "ActionError";
+		const idxStr = typeof idx === "number" ? ` at action ${idx}` : "";
+		const short = `ActionError: ${kind}`;
+		return {
+			message: `${operationName} failed${idxStr} (ActionError: ${kind})`,
+			type: "ActionError",
+			kind,
+			index: idx,
+			short
+		};
+	}
+	return {
+		message: `${operationName} failed (TxExecutionError)`,
+		type: "TxExecutionError",
+		kind: "TxExecutionError",
+		short: "TxExecutionError"
+	};
+}
+
+//#endregion
+//#region src/core/NearClient.ts
+let RpcCallType = /* @__PURE__ */ function(RpcCallType$1) {
+	RpcCallType$1["Query"] = "query";
+	RpcCallType$1["View"] = "view";
+	RpcCallType$1["Send"] = "send_tx";
+	RpcCallType$1["Block"] = "block";
+	RpcCallType$1["Call"] = "call_function";
+	return RpcCallType$1;
+}({});
+var SignedTransaction = class SignedTransaction {
+	transaction;
+	signature;
+	borsh_bytes;
+	constructor(data) {
+		this.transaction = data.transaction;
+		this.signature = data.signature;
+		this.borsh_bytes = data.borsh_bytes;
+	}
+	static fromPlain(input) {
+		return new SignedTransaction({
+			transaction: input.transaction,
+			signature: input.signature,
+			borsh_bytes: input.borsh_bytes
+		});
+	}
+	encode() {
+		return new Uint8Array(this.borsh_bytes).buffer;
+	}
+	base64Encode() {
+		return base64Encode(this.encode());
+	}
+	static decode(bytes) {
+		throw new Error("SignedTransaction.decode(): borsh deserialization not implemented");
+	}
+};
+function toArrayBufferFromUnknownBytes(bytes) {
+	if (!bytes) return null;
+	if (Array.isArray(bytes)) return new Uint8Array(bytes).buffer;
+	if (ArrayBuffer.isView(bytes)) {
+		const view = bytes;
+		return view.buffer.slice(view.byteOffset, view.byteOffset + view.byteLength);
+	}
+	if (bytes instanceof ArrayBuffer) return bytes;
+	return null;
+}
+function encodeSignedTransactionBase64(signed) {
+	const maybeSigned = signed?.signedTransaction;
+	const txPayload = maybeSigned && typeof maybeSigned === "object" ? maybeSigned : signed;
+	const maybeBase64 = txPayload.base64Encode;
+	if (isFunction(maybeBase64)) return maybeBase64.call(txPayload);
+	const maybeEncode = txPayload.encode;
+	if (isFunction(maybeEncode)) {
+		const buf = maybeEncode.call(txPayload);
+		return base64Encode(buf);
+	}
+	const snakeBuf = toArrayBufferFromUnknownBytes(txPayload.borsh_bytes);
+	if (snakeBuf) return base64Encode(snakeBuf);
+	const camelBuf = toArrayBufferFromUnknownBytes(txPayload.borshBytes);
+	if (camelBuf) return base64Encode(camelBuf);
+	throw new Error("Invalid signed transaction payload: cannot serialize to base64");
+}
+var MinimalNearClient = class MinimalNearClient {
+	rpcUrls;
+	constructor(rpcUrl) {
+		this.rpcUrls = MinimalNearClient.normalizeRpcUrls(rpcUrl);
+	}
+	static normalizeRpcUrls(input) {
+		const urls = Array.isArray(input) ? input : input.split(/[\s,]+/).map((url) => url.trim()).filter(Boolean);
+		const normalized = urls.map((url) => {
+			try {
+				return new URL(url).toString();
+			} catch (err) {
+				const message = errorMessage(err) || `Invalid NEAR RPC URL: ${url}`;
+				throw new Error(message);
+			}
+		});
+		if (!normalized.length) throw new Error("NEAR RPC URL cannot be empty");
+		return Array.from(new Set(normalized));
+	}
+	/** Build a JSON-RPC 2.0 POST body (stringified). */
+	buildRequestBody(method, params) {
+		return JSON.stringify({
+			jsonrpc: "2.0",
+			id: crypto.randomUUID(),
+			method,
+			params
+		});
+	}
+	/** Perform a single POST to one endpoint and return parsed RpcResponse. */
+	async postOnce(url, requestBody) {
+		const response = await fetch(url, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: requestBody
+		});
+		if (!response.ok) throw new Error(`RPC request failed: ${response.status} ${response.statusText}`);
+		const text = await response.text();
+		if (!text?.trim()) throw new Error("Empty response from RPC server");
+		return JSON.parse(text);
+	}
+	/** Try each configured RPC endpoint in order and return the first successful RpcResponse. */
+	async requestWithFallback(requestBody) {
+		let lastError;
+		for (const [index, url] of this.rpcUrls.entries()) try {
+			const result = await this.postOnce(url, requestBody);
+			if (index > 0) console.warn(`[NearClient] RPC succeeded via fallback: ${url}`);
+			return result;
+		} catch (err) {
+			lastError = err;
+			const remaining = index < this.rpcUrls.length - 1;
+			console.warn(`[NearClient] RPC call to ${url} failed${remaining ? ", trying next" : ""}: ${errorMessage(err) || "RPC request failed"}`);
+			if (!remaining) throw err instanceof Error ? err : new Error(String(err));
+		}
+		throw new Error(errorMessage(lastError) || "RPC request failed");
+	}
+	/** Validate and unwrap RpcResponse into the typed result with rich error forwarding. */
+	unwrapRpcResult(rpc, operationName) {
+		if (rpc.error) throw NearRpcError.fromRpcResponse(operationName, rpc);
+		const result = rpc.result;
+		if (result?.error) {
+			const msg = typeof result.error === "string" ? result.error : JSON.stringify(result.error);
+			throw new NearRpcError({
+				message: `${operationName} Error: ${msg}`,
+				short: "RpcError",
+				type: "RpcError"
+			});
+		}
+		return rpc.result;
+	}
+	/**
+	* Execute RPC call with proper error handling and result extraction
+	*/
+	async makeRpcCall(method, params, operationName) {
+		const requestBody = this.buildRequestBody(method, params);
+		const rpc = await this.requestWithFallback(requestBody);
+		return this.unwrapRpcResult(rpc, operationName);
+	}
+	async query(params) {
+		return this.makeRpcCall(RpcCallType.Query, params, "Query");
+	}
+	async viewAccessKey(accountId, publicKey, finalityQuery) {
+		const publicKeyStr = publicKey;
+		const finality = finalityQuery?.finality || "final";
+		const params = {
+			request_type: "view_access_key",
+			finality,
+			account_id: accountId,
+			public_key: publicKeyStr
+		};
+		return this.makeRpcCall(RpcCallType.Query, params, "View Access Key");
+	}
+	async viewAccessKeyList(accountId, finalityQuery) {
+		const finality = finalityQuery?.finality || "final";
+		const params = {
+			request_type: "view_access_key_list",
+			finality,
+			account_id: accountId
+		};
+		return this.makeRpcCall(RpcCallType.Query, params, "View Access Key List");
+	}
+	async viewAccount(accountId) {
+		const params = {
+			request_type: "view_account",
+			finality: "final",
+			account_id: accountId
+		};
+		return this.makeRpcCall(RpcCallType.Query, params, "View Account");
+	}
+	async viewCode(accountId, finalityQuery) {
+		const finality = finalityQuery?.finality || "final";
+		const params = {
+			request_type: "view_code",
+			finality,
+			account_id: accountId
+		};
+		const result = await this.makeRpcCall(RpcCallType.Query, params, "View Code");
+		const codeBase64 = result?.code_base64;
+		if (typeof codeBase64 !== "string" || !codeBase64.length) throw new Error("Invalid View Code response: missing code_base64");
+		return base64Decode(codeBase64);
+	}
+	async viewBlock(params) {
+		return this.makeRpcCall(RpcCallType.Block, params, "View Block");
+	}
+	async sendTransaction(signedTransaction, waitUntil = DEFAULT_WAIT_STATUS.executeAction) {
+		const params = {
+			signed_tx_base64: encodeSignedTransactionBase64(signedTransaction),
+			wait_until: waitUntil
+		};
+		const maxAttempts = 5;
+		let lastError = null;
+		for (let attempt = 1; attempt <= maxAttempts; attempt++) try {
+			const outcome = await this.makeRpcCall(RpcCallType.Send, params, "Send Transaction");
+			const status = outcome?.status;
+			if (status && typeof status === "object" && "Failure" in status) {
+				const failure = status.Failure;
+				throw NearRpcError.fromOutcome("Send Transaction", outcome, failure);
+			}
+			return outcome;
+		} catch (err) {
+			lastError = err;
+			const msg = errorMessage(err);
+			const retryable = /server error|internal|temporar|timeout|too many requests|429|unavailable|bad gateway|gateway timeout/i.test(msg || "");
+			if (!retryable || attempt === maxAttempts) throw err;
+			const base = 200 * Math.pow(2, attempt - 1);
+			const jitter = Math.floor(Math.random() * 150);
+			await new Promise((r) => setTimeout(r, base + jitter));
+		}
+		throw lastError instanceof Error ? lastError : new Error(String(lastError));
+	}
+	async txStatus(txHash, senderAccountId) {
+		const params = {
+			tx_hash: txHash,
+			sender_account_id: senderAccountId
+		};
+		return this.makeRpcCall("EXPERIMENTAL_tx_status", params, "Tx Status");
+	}
+	async callFunction(contractId, method, args, blockQuery) {
+		const rpcParams = {
+			request_type: "call_function",
+			finality: "final",
+			account_id: contractId,
+			method_name: method,
+			args_base64: base64Encode(new TextEncoder().encode(JSON.stringify(args)).buffer)
+		};
+		const result = await this.makeRpcCall(RpcCallType.Query, rpcParams, "View Function");
+		const resultBytes = result.result;
+		if (!Array.isArray(resultBytes)) return result;
+		const resultString = String.fromCharCode(...resultBytes);
+		if (!resultString.trim()) return null;
+		try {
+			const parsed = JSON.parse(resultString);
+			return parsed;
+		} catch (parseError) {
+			console.warn("Failed to parse result as JSON, returning as string:", parseError);
+			console.warn("Raw result string:", resultString);
+			const cleanString = resultString.replace(/^"|"$/g, "");
+			return cleanString;
+		}
+	}
+	async view(params) {
+		return this.callFunction(params.account, params.method, params.args);
+	}
+	async getAccessKeys({ account, block_id }) {
+		const params = {
+			request_type: "view_access_key_list",
+			account_id: account,
+			finality: "final"
+		};
+		if (block_id) {
+			params.block_id = block_id;
+			delete params.finality;
+		}
+		const accessKeyList = await this.makeRpcCall(RpcCallType.Query, params, "View Access Key List");
+		const fullAccessKeys = [];
+		const functionCallAccessKeys = [];
+		for (const key of accessKeyList.keys) if (key.access_key.permission === "FullAccess") fullAccessKeys.push(key);
+		else if (key.access_key.permission && typeof key.access_key.permission === "object" && "FunctionCall" in key.access_key.permission) functionCallAccessKeys.push(key);
+		return {
+			fullAccessKeys,
+			functionCallAccessKeys
+		};
+	}
+};
+
+//#endregion
+//#region src/core/OfflineExport/overlay.ts
+/**
+* Offline Export overlay helpers.
+*
+* For clarity and simplicity, this implementation opens the offline route
+* in a new browser tab/window instead of mounting a fullscreen iframe overlay.
+*/
+function openOfflineExportWindow(opts = {}) {
+	const walletOrigin = opts.walletOrigin || (typeof window !== "undefined" ? window.location.origin : "");
+	const urlObj = new URL("/offline-export/", walletOrigin);
+	if (opts.accountId) try {
+		urlObj.searchParams.set("accountId", String(opts.accountId));
+	} catch {}
+	const url = urlObj.toString();
+	const globalOpen = globalThis.open;
+	const winOpen = typeof window !== "undefined" ? window.open : void 0;
+	const openFn = typeof globalOpen === "function" ? globalOpen.bind(globalThis) : typeof winOpen === "function" ? winOpen.bind(window) : void 0;
+	if (openFn) {
+		try {
+			openFn(url, opts.target || "_blank", "noopener,noreferrer");
+		} catch {}
+		return;
+	}
+	try {
+		if (typeof window !== "undefined" && window.location) window.location.href = url;
+	} catch {}
+}
+/**
+* Open the offline-export route if the environment is offline.
+* Returns true when it handled opening the route, false otherwise.
+*/
+/** Lightweight environment probe for offline state */
+function isOffline() {
+	return typeof navigator !== "undefined" && navigator.onLine === false;
+}
+/** Open the offline-export route, preferring the router when provided */
+async function openOfflineExport(args) {
+	if (typeof args.routerOpen === "function") {
+		await args.routerOpen({ accountId: args.accountId });
+		return;
+	}
+	const walletOrigin = args.walletOrigin || (typeof window !== "undefined" ? window.location.origin : void 0);
+	openOfflineExportWindow({
+		walletOrigin,
+		target: args.target ?? "_blank",
+		accountId: args.accountId
+	});
+}
+
+//#endregion
+export { MinimalNearClient, SignedTransaction, isOffline, openOfflineExport, openOfflineExportWindow };

package/dist/esm/sdk/passkey-halo-loading.js

@@ -1,4 +1,4 @@
-import { LitElementWithProps, W3A_PASSKEY_HALO_LOADING_ID, ensureExternalStyles, x } from "./HaloBorder-D7vjXHnY.js";
+import { LitElementWithProps, W3A_PASSKEY_HALO_LOADING_ID, ensureExternalStyles, x } from "./HaloBorder-DYOOQFjI.js";
 
 //#region src/core/WebAuthnManager/LitComponents/PasskeyHaloLoading/index.ts
 var PasskeyHaloLoadingElement = class extends LitElementWithProps {

package/dist/esm/sdk/registration-BP9M3tE1.js

@@ -0,0 +1,165 @@
+import "./css-loader-CAIkFQ3i.js";
+import "./validation-BTq6LGPp.js";
+import "./events-D2g80q67.js";
+import "./actions-fHadejPs.js";
+import "./base64-dqpWgddX.js";
+import "./vrf-worker-BzQsJ5BW.js";
+import "./accountIds-DVDhXwVA.js";
+import { sha256Base64UrlUtf8 } from "./intentDigest-yivVENNK.js";
+import "./tags-ByzxP7Cc.js";
+import "./lit-events-Bb4tAEO2.js";
+import "./tx-confirmer-wrapper-DWKpXTUW.js";
+import { toError } from "./errors-DevlT39D.js";
+import { isSerializedRegistrationCredential, serializeRegistrationCredentialWithPRF } from "./safari-fallbacks-BcMFntiP.js";
+import "./touchIdPrompt-JPhrOx8o.js";
+import { ERROR_MESSAGES, getIntentDigest, getNearAccountId, getRegisterAccountPayload, isUserCancelledSecureConfirm } from "./collectAuthenticationCredentialForVrfChallenge-DqzPzwvU.js";
+import { createConfirmSession, createConfirmTxFlowAdapters } from "./createAdapters-1Hmc1vVC.js";
+
+//#region src/core/WebAuthnManager/VrfWorkerManager/confirmTxFlow/flows/registration.ts
+async function handleRegistrationFlow(ctx, request, worker, opts) {
+	const { confirmationConfig, transactionSummary } = opts;
+	const adapters = createConfirmTxFlowAdapters(ctx);
+	const session = createConfirmSession({
+		adapters,
+		worker,
+		request,
+		confirmationConfig,
+		transactionSummary
+	});
+	const nearAccountId = getNearAccountId(request);
+	console.debug("[RegistrationFlow] start", {
+		nearAccountId,
+		uiMode: confirmationConfig?.uiMode,
+		behavior: confirmationConfig?.behavior,
+		theme: confirmationConfig?.theme,
+		intentDigest: transactionSummary?.intentDigest
+	});
+	const nearRpc = await adapters.near.fetchNearContext({
+		nearAccountId,
+		txCount: 1,
+		reserveNonces: true
+	});
+	if (nearRpc.error && !nearRpc.transactionContext) return session.confirmAndCloseModal({
+		requestId: request.requestId,
+		intentDigest: getIntentDigest(request),
+		confirmed: false,
+		error: `${ERROR_MESSAGES.nearRpcFailed}: ${nearRpc.details}`
+	});
+	const transactionContext = nearRpc.transactionContext;
+	session.setReservedNonces(nearRpc.reservedNonces);
+	const computeBoundIntentDigestB64u = async () => {
+		const uiIntentDigest = getIntentDigest(request);
+		if (!uiIntentDigest) throw new Error("Missing intentDigest for registration flow");
+		return sha256Base64UrlUtf8(uiIntentDigest);
+	};
+	const rpId = adapters.vrf.getRpId();
+	const boundIntentDigestB64u = await computeBoundIntentDigestB64u();
+	const bootstrap = await adapters.vrf.generateVrfKeypairBootstrap({
+		vrfInputData: {
+			userId: nearAccountId,
+			rpId,
+			blockHeight: transactionContext.txBlockHeight,
+			blockHash: transactionContext.txBlockHash,
+			intentDigest: boundIntentDigestB64u
+		},
+		saveInMemory: true,
+		sessionId: request.requestId
+	});
+	let uiVrfChallenge = bootstrap.vrfChallenge;
+	console.debug("[RegistrationFlow] VRF bootstrap ok", { blockHeight: uiVrfChallenge.blockHeight });
+	const { confirmed, error: uiError } = await session.promptUser({ vrfChallenge: uiVrfChallenge });
+	if (!confirmed) {
+		console.debug("[RegistrationFlow] user cancelled");
+		return session.confirmAndCloseModal({
+			requestId: request.requestId,
+			intentDigest: getIntentDigest(request),
+			confirmed: false,
+			error: uiError
+		});
+	}
+	try {
+		const refreshed = await adapters.vrf.maybeRefreshVrfChallenge(request, nearAccountId);
+		uiVrfChallenge = refreshed.vrfChallenge;
+		session.updateUI({ vrfChallenge: uiVrfChallenge });
+		console.debug("[RegistrationFlow] VRF JIT refresh ok", { blockHeight: uiVrfChallenge.blockHeight });
+	} catch (e) {
+		console.debug("[RegistrationFlow] VRF JIT refresh skipped", e);
+	}
+	let credential;
+	let deviceNumber = request.payload?.deviceNumber ?? 1;
+	const tryCreate = async (dn) => {
+		console.debug("[RegistrationFlow] navigator.credentials.create start", { deviceNumber: dn });
+		return await adapters.webauthn.createRegistrationCredential({
+			nearAccountId,
+			challenge: uiVrfChallenge,
+			deviceNumber: dn
+		});
+	};
+	try {
+		try {
+			credential = await tryCreate(deviceNumber);
+			console.debug("[RegistrationFlow] credentials.create ok");
+		} catch (e) {
+			const err = toError(e);
+			const name = String(err?.name || "");
+			const msg = String(err?.message || "");
+			const isDuplicate = name === "InvalidStateError" || /excluded|already\s*registered/i.test(msg);
+			if (isDuplicate) {
+				const nextDeviceNumber = deviceNumber !== void 0 && Number.isFinite(deviceNumber) ? deviceNumber + 1 : 2;
+				console.debug("[RegistrationFlow] duplicate credential, retry with next deviceNumber", { nextDeviceNumber });
+				deviceNumber = nextDeviceNumber;
+				getRegisterAccountPayload(request).deviceNumber = nextDeviceNumber;
+				request.intentDigest = request.type === "registerAccount" ? `register:${nearAccountId}:${nextDeviceNumber}` : `device2-register:${nearAccountId}:${nextDeviceNumber}`;
+				const retryBoundIntentDigestB64u = await computeBoundIntentDigestB64u();
+				const retryBootstrap = await adapters.vrf.generateVrfKeypairBootstrap({
+					vrfInputData: {
+						userId: nearAccountId,
+						rpId,
+						blockHeight: transactionContext.txBlockHeight,
+						blockHash: transactionContext.txBlockHash,
+						intentDigest: retryBoundIntentDigestB64u
+					},
+					saveInMemory: true,
+					sessionId: request.requestId
+				});
+				uiVrfChallenge = retryBootstrap.vrfChallenge;
+				session.updateUI({ vrfChallenge: uiVrfChallenge });
+				credential = await tryCreate(nextDeviceNumber);
+			} else {
+				console.error("[RegistrationFlow] credentials.create failed (non-duplicate)", {
+					name,
+					msg
+				});
+				throw err;
+			}
+		}
+		const serialized = isSerializedRegistrationCredential(credential) ? credential : serializeRegistrationCredentialWithPRF({
+			credential,
+			firstPrfOutput: true,
+			secondPrfOutput: true
+		});
+		session.confirmAndCloseModal({
+			requestId: request.requestId,
+			intentDigest: getIntentDigest(request),
+			confirmed: true,
+			credential: serialized,
+			vrfChallenge: uiVrfChallenge,
+			transactionContext
+		});
+	} catch (err) {
+		const cancelled = isUserCancelledSecureConfirm(err);
+		const msg = String(toError(err)?.message || err || "");
+		if (/Missing PRF result/i.test(msg) || /Missing PRF results/i.test(msg)) return session.cleanupAndRethrow(err);
+		if (cancelled) window.parent?.postMessage({ type: "WALLET_UI_CLOSED" }, "*");
+		const isPrfBrowserUnsupported = /WebAuthn PRF output is missing from navigator\.credentials\.create\(\)/i.test(msg) || /does not fully support the WebAuthn PRF extension during registration/i.test(msg) || /roaming hardware authenticators .* not supported in this flow/i.test(msg);
+		return session.confirmAndCloseModal({
+			requestId: request.requestId,
+			intentDigest: getIntentDigest(request),
+			confirmed: false,
+			error: cancelled ? ERROR_MESSAGES.cancelled : isPrfBrowserUnsupported ? msg : ERROR_MESSAGES.collectCredentialsFailed
+		});
+	}
+}
+
+//#endregion
+export { handleRegistrationFlow };