@seams/wallet 0.6.2 → 0.7.1

package/dist/{public/sdk/exactSessionState-Bt0HforB.js → esm/sdk/exactSessionState-CiD5fBEs.js}

@@ -1,19 +1,19 @@
-import { R as parseWalletId, m as parseCapabilityInstanceRef } from "./normalize-BephcEIF.js";
+import { O as parseWalletId, i as parseCapabilityInstanceRef } from "./domainIds-lcrFg6Sa.js";
+import { g as requireNonEmptyString, m as requireArray, v as requireRecordCopy } from "./validation-gat4LEKm.js";
 import { n as secureRandomBase64Url } from "./secureRandomId-BORsmdS4.js";
-import { l as activeWalletSessionV1RecordsEqual } from "./device-linking-DpVGjSeq.js";
-import { y as parseNearEd25519SigningKeyId } from "./registrationIntent-DwAIMQYh.js";
-import { a as thresholdEcdsaChainTargetFromRequest } from "./ecdsaChainTarget-BOTPGIU_.js";
-import { o as isWalletAuthMethod } from "./signerDomain-DDLiwuYS.js";
-import { t as toAccountId } from "./accountIds-Ck4GAQfm.js";
-import { Bt as parseWalletAuthAuthorityRef } from "./ecdsaPresignLifecycle-CnSnzoRJ.js";
-import { h as parseWalletSessionId, m as parseWalletSessionAuthorizationId } from "./capabilityKinds-jwCEaqBU.js";
-import { at as walletAuthMethodBindingFromRaw } from "./evmFamilyEcdsaIdentity-_kuKSW35.js";
-import { d as parseEcdsaThresholdKeyId } from "./keyMaterialBrands-BbjCfzXv.js";
-import { t as parseSignerSlot } from "./signerSlot-DbNAs-kc.js";
-import { _ as NonceCoordinatorDegradationReason, v as NonceCoordinatorFallback, x as NonceLeaseState } from "./nonceLaneKeys-B_RcSS6M.js";
-import { t as createEvmClient } from "./EvmClient-CHw6txjt.js";
-import { n as resolveAppearanceTheme } from "./configHelpers-DB73zYvO.js";
-import { n as getDefaultCspNonce, r as appearanceTokenCssRule, t as createCspStylesheetManager } from "./csp-stylesheet-DLj_a6t_.js";
+import { Dt as activeWalletSessionV1RecordsEqual, et as parseWalletAuthAuthorityRef } from "./ecdsaPresignLifecycle-BFOTNYCK.js";
+import { h as parseWalletSessionId, m as parseWalletSessionAuthorizationId } from "./capabilityKinds-hvYqa6S_.js";
+import { a as thresholdEcdsaChainTargetFromRequest } from "./ecdsaChainTarget-Bl-JWyuw.js";
+import { o as isWalletAuthMethod } from "./signerDomain-IEAVrOrc.js";
+import { t as toAccountId } from "./accountIds-DhIPGOSN.js";
+import { z as walletAuthMethodBindingFromRaw } from "./evmFamilyEcdsaIdentity-Co5XDcEA.js";
+import { a as parseNearEd25519SigningKeyId } from "./registrationIds-DLSdEKSv.js";
+import { s as parseEcdsaThresholdKeyId } from "./keyMaterialBrands-CX41hur6.js";
+import { t as parseSignerSlot } from "./signerSlot-_ovonwVX.js";
+import { _ as NonceCoordinatorDegradationReason, v as NonceCoordinatorFallback, x as NonceLeaseState } from "./nonceLaneKeys-C3c9lG6u.js";
+import { t as createEvmClient } from "./EvmClient-f3gUhS2L.js";
+import { n as resolveAppearanceTheme } from "./configHelpers-vAQCzUD0.js";
+import { n as getDefaultCspNonce, r as appearanceTokenCssRule, t as createCspStylesheetManager } from "./csp-stylesheet-btENhsNp.js";
 //#region src/core/signingEngine/webauthnAuth/fallbacks/safari-fallbacks.ts
 const WebAuthnBridgeMessage = {
 	Create: "WALLET_WEBAUTHN_CREATE",
@@ -652,6 +652,9 @@ built.GREY_COLORS;
 built.GRADIENTS;
 const DARK_THEME = built.DARK_THEME;
 const LIGHT_THEME = built.LIGHT_THEME;
+const WALLET_IFRAME_SURFACE_MIN_COMPACT_WIDTH_CSS_PX = 280;
+const WALLET_IFRAME_SURFACE_MIN_COMPACT_HEIGHT_CSS_PX = 280;
+const WALLET_IFRAME_SURFACE_MAX_MODAL_WIDTH_CSS_PX = 560;
 function isWalletIframeModalGeometry(geometry) {
 	return geometry.kind === "provisional_centered_modal" || geometry.kind === "centered_modal" || geometry.kind === "viewport_fallback";
 }
@@ -692,7 +695,7 @@ function fallbackGeometry(viewport, reason) {
 	};
 }
 function viewportCannotFitCompactSurface(viewport) {
-	return viewport.widthCssPx - 32 < 280 || viewport.heightCssPx - 32 < 280;
+	return viewport.widthCssPx - 32 < WALLET_IFRAME_SURFACE_MIN_COMPACT_WIDTH_CSS_PX || viewport.heightCssPx - 32 < WALLET_IFRAME_SURFACE_MIN_COMPACT_HEIGHT_CSS_PX;
 }
 function centeredGeometry(viewport, widthCssPx, heightCssPx, kind) {
 	return {
@@ -727,22 +730,22 @@ function fullViewportDrawerGeometry(viewport, kind) {
 function isDrawerPresentation(presentation) {
 	return presentation.kind === "drawer";
 }
-function provisionalWalletIframeSurfaceGeometry(presentation, viewportInput, maxModalWidthCssPx = 560) {
+function provisionalWalletIframeSurfaceGeometry(presentation, viewportInput, maxModalWidthCssPx = WALLET_IFRAME_SURFACE_MAX_MODAL_WIDTH_CSS_PX) {
 	const viewport = normalizedViewport(viewportInput);
 	if (isDrawerPresentation(presentation)) return fullViewportDrawerGeometry(viewport, "provisional_bottom_drawer");
 	if (viewportCannotFitCompactSurface(viewport)) return fallbackGeometry(viewport, "small_visual_viewport");
 	const availableWidth = viewport.widthCssPx - 32;
 	const availableHeight = viewport.heightCssPx - 32;
-	return centeredGeometry(viewport, clamp(maxModalWidthCssPx, 280, Math.min(maxModalWidthCssPx, availableWidth)), Math.min(320, availableHeight), "provisional_centered_modal");
+	return centeredGeometry(viewport, clamp(maxModalWidthCssPx, WALLET_IFRAME_SURFACE_MIN_COMPACT_WIDTH_CSS_PX, Math.min(maxModalWidthCssPx, availableWidth)), Math.min(320, availableHeight), "provisional_centered_modal");
 }
-function measuredWalletIframeSurfaceGeometry(presentation, viewportInput, measurement, maxModalWidthCssPx = 560) {
+function measuredWalletIframeSurfaceGeometry(presentation, viewportInput, measurement, maxModalWidthCssPx = WALLET_IFRAME_SURFACE_MAX_MODAL_WIDTH_CSS_PX) {
 	const viewport = normalizedViewport(viewportInput);
 	if (isDrawerPresentation(presentation)) return fullViewportDrawerGeometry(viewport, "bottom_drawer");
 	if (!isFinitePositive(measurement.widthCssPx) || !isFinitePositive(measurement.heightCssPx)) throw new Error("Wallet iframe surface measurement is invalid");
 	if (viewportCannotFitCompactSurface(viewport)) return fallbackGeometry(viewport, "small_visual_viewport");
 	const availableWidth = viewport.widthCssPx - 32;
 	const availableHeight = viewport.heightCssPx - 32;
-	return centeredGeometry(viewport, clamp(measurement.widthCssPx, 280, Math.min(maxModalWidthCssPx, availableWidth)), clamp(measurement.heightCssPx, 1, availableHeight), "centered_modal");
+	return centeredGeometry(viewport, clamp(measurement.widthCssPx, WALLET_IFRAME_SURFACE_MIN_COMPACT_WIDTH_CSS_PX, Math.min(maxModalWidthCssPx, availableWidth)), clamp(measurement.heightCssPx, 1, availableHeight), "centered_modal");
 }
 function resolveWalletIframeSurfaceGeometry(args) {
 	const measurement = args.measurement;
@@ -2030,7 +2033,7 @@ function parseWalletIframeExactSessionLockResult(value) {
 	}
 }
 function parseWalletSessionAppIdentity(value) {
-	const record = requireRecord(value, "Wallet Session appIdentity");
+	const record = requireRecordCopy(value, "Wallet Session appIdentity");
 	switch (record.kind) {
 		case "anonymous": return { kind: "anonymous" };
 		case "unresolvable": return {
@@ -2057,7 +2060,7 @@ function parseWalletSessionAppIdentity(value) {
 	}
 }
 function parseWalletSessionCapabilityProjection(value) {
-	const record = requireRecord(value, "Wallet Session capabilityProjection");
+	const record = requireRecordCopy(value, "Wallet Session capabilityProjection");
 	switch (record.kind) {
 		case "not_requested": return { kind: "not_requested" };
 		case "unresolvable": return {
@@ -2078,7 +2081,7 @@ function parseWalletSessionCapabilityProjection(value) {
 	}
 }
 function parseWalletUnlockSubjectSet(value) {
-	const record = requireRecord(value, "wallet unlock subject set");
+	const record = requireRecordCopy(value, "wallet unlock subject set");
 	if (record.kind !== "wallet_unlock_subject_set") throw new Error("Wallet unlock subject set kind is invalid");
 	const walletId = requireWalletId(record.walletId);
 	const subjects = requireNonEmptyArray(record.subjects, "wallet unlock subjects").map(parseWalletUnlockSubject);
@@ -2092,7 +2095,7 @@ function parseWalletUnlockSubjectSet(value) {
 	};
 }
 function parseWalletUnlockSubject(value) {
-	const record = requireRecord(value, "wallet unlock subject");
+	const record = requireRecordCopy(value, "wallet unlock subject");
 	const walletId = requireWalletId(record.walletId);
 	switch (record.kind) {
 		case "near_ed25519_wallet": {
@@ -2123,7 +2126,7 @@ function parseWalletUnlockSubject(value) {
 	}
 }
 function parseWalletSessionCapabilityReadiness(value) {
-	const record = requireRecord(value, "Wallet Session capability readiness");
+	const record = requireRecordCopy(value, "Wallet Session capability readiness");
 	switch (record.kind) {
 		case "near_ed25519": return {
 			kind: "near_ed25519",
@@ -2149,7 +2152,7 @@ function parseEcdsaWalletUnlockSubject(value) {
 	return subject;
 }
 function parseEcdsaCapabilityTargets(value) {
-	const record = requireRecord(value, "ECDSA capability targets");
+	const record = requireRecordCopy(value, "ECDSA capability targets");
 	switch (record.kind) {
 		case "no_configured_target": return { kind: "no_configured_target" };
 		case "configured_targets": {
@@ -2165,14 +2168,14 @@ function parseEcdsaCapabilityTargets(value) {
 	}
 }
 function parseEcdsaCapabilityTargetLane(value) {
-	const record = requireRecord(value, "ECDSA capability target lane");
+	const record = requireRecordCopy(value, "ECDSA capability target lane");
 	return {
-		chainTarget: thresholdEcdsaChainTargetFromRequest(requireRecord(record.chainTarget, "ECDSA chain target")),
+		chainTarget: thresholdEcdsaChainTargetFromRequest(requireRecordCopy(record.chainTarget, "ECDSA chain target")),
 		readiness: parseWalletSessionCapabilityLaneReadiness(record.readiness)
 	};
 }
 function parseWalletSessionCapabilityLaneReadiness(value) {
-	const record = requireRecord(value, "Wallet Session capability lane readiness");
+	const record = requireRecordCopy(value, "Wallet Session capability lane readiness");
 	switch (record.kind) {
 		case "ready": return { kind: "ready" };
 		case "pending": return {
@@ -2222,10 +2225,10 @@ function walletIdFromAuthBinding(binding) {
 }
 function parseNullableClientUserData(value, expectedWalletId) {
 	if (value === null) return null;
-	const record = requireRecord(value, "Wallet Session userData");
+	const record = requireRecordCopy(value, "Wallet Session userData");
 	const walletId = requireWalletId(record.walletId);
 	if (walletId !== expectedWalletId) throw new Error("Wallet Session userData wallet identity disagrees");
-	const passkeyCredential = requireRecord(record.passkeyCredential, "passkeyCredential");
+	const passkeyCredential = requireRecordCopy(record.passkeyCredential, "passkeyCredential");
 	const signerSlot = parseSignerSlot(record.signerSlot);
 	if (signerSlot === null) throw new Error("Wallet Session userData signerSlot is invalid");
 	const authMethod = parseNullableWalletAuthMethod(record.authMethod);
@@ -2255,10 +2258,10 @@ function parseNullableWalletAuthMethod(value) {
 	return value;
 }
 function parseUserPreferences(value) {
-	const record = requireRecord(value, "Wallet Session user preferences");
+	const record = requireRecordCopy(value, "Wallet Session user preferences");
 	if (typeof record.useRelayer !== "boolean") throw new Error("Wallet Session user preferences useRelayer is invalid");
 	if (record.useNetwork !== "testnet" && record.useNetwork !== "mainnet") throw new Error("Wallet Session user preferences useNetwork is invalid");
-	const confirmation = requireRecord(record.confirmationConfig, "Wallet Session confirmationConfig");
+	const confirmation = requireRecordCopy(record.confirmationConfig, "Wallet Session confirmationConfig");
 	if (confirmation.uiMode !== "none" && confirmation.uiMode !== "modal" && confirmation.uiMode !== "drawer") throw new Error("Wallet Session confirmationConfig uiMode is invalid");
 	if (confirmation.behavior !== "requireClick" && confirmation.behavior !== "skipClick") throw new Error("Wallet Session confirmationConfig behavior is invalid");
 	const autoProceedDelay = confirmation.autoProceedDelay === void 0 ? void 0 : requireNonNegativeSafeInteger(confirmation.autoProceedDelay, "confirmationConfig.autoProceedDelay");
@@ -2274,8 +2277,8 @@ function parseUserPreferences(value) {
 }
 function parseNullableNonceDiagnostics(value) {
 	if (value === null) return null;
-	const record = requireRecord(value, "Wallet Session nonce diagnostics");
-	const near = requireRecord(record.near, "near nonce diagnostics");
+	const record = requireRecordCopy(value, "Wallet Session nonce diagnostics");
+	const near = requireRecordCopy(record.near, "near nonce diagnostics");
 	return {
 		leaseCount: requireNonNegativeSafeInteger(record.leaseCount, "nonce leaseCount"),
 		leasesByState: parseRequiredNonceStateCounts(record.leasesByState),
@@ -2293,7 +2296,7 @@ function parseNullableNonceDiagnostics(value) {
 	};
 }
 function parseNonceMetrics(value) {
-	const record = requireRecord(value, "nonce metrics");
+	const record = requireRecordCopy(value, "nonce metrics");
 	return {
 		atMs: requireNonNegativeSafeInteger(record.atMs, "nonce metrics atMs"),
 		...record.accountId === void 0 ? {} : { accountId: requireNonEmptyString(record.accountId, "nonce metrics accountId") },
@@ -2314,7 +2317,7 @@ function parseNonceMetrics(value) {
 	};
 }
 function parseNonceOutcomeMetrics(value) {
-	const record = requireRecord(value, "nonce outcome metrics");
+	const record = requireRecordCopy(value, "nonce outcome metrics");
 	return {
 		droppedCount: requireNonNegativeSafeInteger(record.droppedCount, "droppedCount"),
 		replacedCount: requireNonNegativeSafeInteger(record.replacedCount, "replacedCount"),
@@ -2328,7 +2331,7 @@ function parseNonceOutcomeMetrics(value) {
 	};
 }
 function parseStringCountMap(value, label) {
-	const record = requireRecord(value, label);
+	const record = requireRecordCopy(value, label);
 	const parsed = {};
 	for (const [key, count] of Object.entries(record)) {
 		if (!key) throw new Error(`${label} key must be non-empty`);
@@ -2337,7 +2340,7 @@ function parseStringCountMap(value, label) {
 	return parsed;
 }
 function parseNonceCoordinationWarning(value) {
-	const record = requireRecord(value, "nonce coordination warning");
+	const record = requireRecordCopy(value, "nonce coordination warning");
 	return {
 		reason: requireNonceDegradationReason(record.reason),
 		...record.laneFamily === void 0 ? {} : { laneFamily: requireNonceLaneFamily(record.laneFamily) },
@@ -2347,7 +2350,7 @@ function parseNonceCoordinationWarning(value) {
 	};
 }
 function parseNonceDiagnosticLane(value) {
-	const record = requireRecord(value, "nonce diagnostic lane");
+	const record = requireRecordCopy(value, "nonce diagnostic lane");
 	const family = requireNonceLaneFamily(record.family);
 	const chain = record.chain === void 0 ? void 0 : requireEvmNonceChain(record.chain);
 	if (family === "near" && (chain !== void 0 || record.chainId !== void 0)) throw new Error("Near nonce diagnostic lane cannot contain EVM chain identity");
@@ -2362,7 +2365,7 @@ function parseNonceDiagnosticLane(value) {
 	};
 }
 function parseRequiredNonceStateCounts(value) {
-	const record = requireRecord(value, "nonce state counts");
+	const record = requireRecordCopy(value, "nonce state counts");
 	return {
 		[NonceLeaseState.Reserved]: requireNonceStateCount(record, NonceLeaseState.Reserved),
 		[NonceLeaseState.Released]: requireNonceStateCount(record, NonceLeaseState.Released),
@@ -2378,7 +2381,7 @@ function parseRequiredNonceStateCounts(value) {
 	};
 }
 function parsePartialNonceStateCounts(value) {
-	const record = requireRecord(value, "nonce state counts");
+	const record = requireRecordCopy(value, "nonce state counts");
 	return {
 		...record[NonceLeaseState.Reserved] === void 0 ? {} : { [NonceLeaseState.Reserved]: requireNonceStateCount(record, NonceLeaseState.Reserved) },
 		...record[NonceLeaseState.Released] === void 0 ? {} : { [NonceLeaseState.Released]: requireNonceStateCount(record, NonceLeaseState.Released) },
@@ -2473,24 +2476,12 @@ function requireFailedCapabilityLaneReason(value) {
 		default: throw new Error("Failed capability lane reason is invalid");
 	}
 }
-function requireRecord(value, label) {
-	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label} must be an object`);
-	return Object.fromEntries(Object.entries(value));
-}
-function requireArray(value, label) {
-	if (!Array.isArray(value)) throw new Error(`${label} must be an array`);
-	return value;
-}
 function requireNonEmptyArray(value, label) {
 	const values = requireArray(value, label);
 	const first = values[0];
 	if (first === void 0) throw new Error(`${label} must be non-empty`);
 	return [first, ...values.slice(1)];
 }
-function requireNonEmptyString(value, label) {
-	if (typeof value !== "string" || !value.trim()) throw new Error(`${label} must be a non-empty string`);
-	return value.trim();
-}
 function requireNullableString(value, label) {
 	if (value === null) return null;
 	return requireNonEmptyString(value, label);

package/dist/esm/sdk/exactSigningLaneIdentity-DQeqPMST.js

@@ -0,0 +1,335 @@
+import { h as parseMpcMaterialActivationRef } from "./domainIds-lcrFg6Sa.js";
+import { E as isImplicitNearAccountId, k as parseNearAccountId } from "./validation-gat4LEKm.js";
+import { f as alphabetizeStringify } from "./chains-BMh3btVo.js";
+import { a as thresholdEcdsaChainTargetFromRequest, c as toWalletId, o as thresholdEcdsaChainTargetKey } from "./ecdsaChainTarget-Bl-JWyuw.js";
+import { A as buildImplicitNearAccountBinding, F as buildWalletIdentity, L as nearEd25519SignerBindingFromRaw, M as buildNearEd25519SignerBinding, j as buildNamedNearAccountBinding, n as buildBaseEvmFamilyEcdsaKeyIdentity, x as toRpId, y as toEvmFamilyEcdsaKeyHandle } from "./evmFamilyEcdsaIdentity-Co5XDcEA.js";
+import { r as SigningSessionIds } from "./types-Dx9fczU7.js";
+//#region src/core/signingEngine/session/identity/exactSigningLaneIdentity.ts
+function assertNeverExactLane(value) {
+	throw new Error(`[SigningSession] unsupported exact signing lane branch: ${String(value)}`);
+}
+function requireRecord(value, field) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`[SigningSession] ${field} must be an object`);
+	return value;
+}
+function requireString(value, field) {
+	const normalized = String(value ?? "").trim();
+	if (!normalized) throw new Error(`[SigningSession] ${field} is required`);
+	return normalized;
+}
+function rejectPresent(record, fields, branch) {
+	for (const field of fields) if (record[field] !== void 0) throw new Error(`[SigningSession] ${branch} exact lane cannot include ${field}`);
+}
+function parseSigningLaneAuthBinding(value) {
+	const auth = requireRecord(value, "exact lane auth");
+	switch (auth.kind) {
+		case "passkey": return {
+			kind: "passkey",
+			rpId: toRpId(auth.rpId),
+			credentialIdB64u: requireString(auth.credentialIdB64u, "credentialIdB64u")
+		};
+		case "email_otp": return {
+			kind: "email_otp",
+			providerSubjectId: requireString(auth.providerSubjectId, "providerSubjectId")
+		};
+		default: throw new Error("[SigningSession] exact lane auth kind is unsupported");
+	}
+}
+function parseExactLaneChainTarget(value) {
+	const target = requireRecord(value, "ECDSA exact lane chainTarget");
+	const parsed = thresholdEcdsaChainTargetFromRequest({
+		kind: target.kind,
+		namespace: target.namespace,
+		chainId: target.chainId,
+		networkSlug: target.networkSlug
+	});
+	if (target.key != null && String(target.key) !== thresholdEcdsaChainTargetKey(parsed)) throw new Error("[SigningSession] exact ECDSA lane chain target key mismatch");
+	return parsed;
+}
+function parseEvmFamilyEcdsaKeyIdentity(value) {
+	const key = requireRecord(value, "ECDSA exact lane key identity");
+	if (key.keyScope !== "evm-family") throw new Error("[SigningSession] exact ECDSA lane keyScope must be evm-family");
+	return buildBaseEvmFamilyEcdsaKeyIdentity({
+		walletId: key.walletId,
+		ecdsaThresholdKeyId: key.ecdsaThresholdKeyId,
+		signingRootId: key.signingRootId,
+		signingRootVersion: key.signingRootVersion,
+		participantIds: key.participantIds,
+		thresholdOwnerAddress: key.thresholdOwnerAddress
+	});
+}
+function parseExactLaneMaterialActivation(value) {
+	const parsed = parseMpcMaterialActivationRef(value);
+	if (!parsed.ok) throw new Error(parsed.error.message);
+	return parsed.value;
+}
+function nearAccountBindingForIdentity(args) {
+	const parsedNearAccountId = parseNearAccountId(args.nearAccountId);
+	if (!parsedNearAccountId.ok) throw new Error(`[SigningSession] invalid exact Ed25519 NEAR account: ${parsedNearAccountId.message}`);
+	const wallet = buildWalletIdentity({ walletId: toWalletId(args.walletId) });
+	if (isImplicitNearAccountId(parsedNearAccountId.value)) return buildImplicitNearAccountBinding({
+		wallet,
+		nearAccountId: parsedNearAccountId.value
+	});
+	return buildNamedNearAccountBinding({
+		wallet,
+		nearAccountId: parsedNearAccountId.value
+	});
+}
+function nearEd25519SignerBindingFromBoundaryFields(input) {
+	const signerSlot = Number(input.signerSlot);
+	if (!Number.isSafeInteger(signerSlot) || signerSlot < 1) throw new Error("[SigningSession] exact Ed25519 signer requires signerSlot >= 1");
+	return buildNearEd25519SignerBinding({
+		account: nearAccountBindingForIdentity({
+			walletId: input.walletId,
+			nearAccountId: input.nearAccountId
+		}),
+		nearEd25519SigningKeyId: input.nearEd25519SigningKeyId,
+		signerSlot
+	});
+}
+function buildEvmFamilyEcdsaSignerBinding(args) {
+	if (String(args.key.walletId) !== String(args.walletId)) throw new Error("[SigningSession] exact ECDSA lane identity wallet mismatch");
+	const materialActivation = parseExactLaneMaterialActivation(args.materialActivation);
+	if (String(materialActivation.materialOwner) !== String(args.walletId)) throw new Error("[SigningSession] exact ECDSA lane material owner mismatch");
+	return {
+		kind: "evm_family_ecdsa_signer",
+		walletId: toWalletId(args.walletId),
+		chainTarget: args.chainTarget,
+		keyHandle: args.keyHandle,
+		key: args.key,
+		materialActivation
+	};
+}
+function parseEvmFamilyEcdsaSignerBinding(value) {
+	const signer = requireRecord(value, "ECDSA exact lane signer");
+	if (signer.kind !== "evm_family_ecdsa_signer") throw new Error("[SigningSession] expected EVM-family ECDSA signer");
+	const chainTarget = parseExactLaneChainTarget(signer.chainTarget);
+	const key = parseEvmFamilyEcdsaKeyIdentity(signer.key);
+	return buildEvmFamilyEcdsaSignerBinding({
+		walletId: toWalletId(signer.walletId),
+		chainTarget,
+		keyHandle: toEvmFamilyEcdsaKeyHandle(signer.keyHandle),
+		key,
+		materialActivation: parseExactLaneMaterialActivation(signer.materialActivation)
+	});
+}
+function canonicalChainTarget(target) {
+	if (target.kind === "evm") return {
+		key: thresholdEcdsaChainTargetKey(target),
+		kind: "evm",
+		namespace: "eip155",
+		chainId: target.chainId
+	};
+	return {
+		key: thresholdEcdsaChainTargetKey(target),
+		kind: "tempo",
+		chainId: target.chainId
+	};
+}
+function canonicalKeyIdentity(key) {
+	return {
+		walletId: String(key.walletId),
+		keyScope: key.keyScope,
+		ecdsaThresholdKeyId: String(key.ecdsaThresholdKeyId),
+		signingRootId: String(key.signingRootId),
+		signingRootVersion: String(key.signingRootVersion),
+		participantIds: [...key.participantIds].map((id) => Number(id)),
+		thresholdOwnerAddress: String(key.thresholdOwnerAddress).toLowerCase()
+	};
+}
+function canonicalAuthBinding(auth) {
+	switch (auth.kind) {
+		case "passkey": return {
+			kind: "passkey",
+			rpId: String(auth.rpId),
+			credentialIdB64u: String(auth.credentialIdB64u)
+		};
+		case "email_otp": return {
+			kind: "email_otp",
+			providerSubjectId: String(auth.providerSubjectId)
+		};
+		default: return assertNeverExactLane(auth);
+	}
+}
+function canonicalSigner(signer) {
+	return {
+		kind: "evm_family_ecdsa_signer",
+		walletId: String(signer.walletId),
+		keyHandle: String(signer.keyHandle),
+		chainTarget: canonicalChainTarget(signer.chainTarget),
+		key: canonicalKeyIdentity(signer.key),
+		materialActivation: {
+			kind: signer.materialActivation.kind,
+			activationId: String(signer.materialActivation.activationId),
+			capability: String(signer.materialActivation.capability),
+			materialOwner: String(signer.materialActivation.materialOwner),
+			keyBinding: String(signer.materialActivation.keyBinding),
+			lifecycleBinding: String(signer.materialActivation.lifecycleBinding),
+			signingWorker: String(signer.materialActivation.signingWorker)
+		}
+	};
+}
+function canonicalExactSigningLaneIdentity(identity) {
+	if (isExactEcdsaSigningLaneIdentity(identity)) return {
+		kind: "exact_signing_lane",
+		signer: canonicalSigner(identity.signer),
+		auth: canonicalAuthBinding(identity.auth)
+	};
+	return {
+		kind: "exact_signing_lane",
+		signer: {
+			kind: "near_ed25519_signer",
+			account: {
+				kind: identity.signer.account.kind,
+				walletId: String(identity.signer.account.wallet.walletId),
+				nearAccountId: String(identity.signer.account.nearAccountId)
+			},
+			nearEd25519SigningKeyId: String(identity.signer.nearEd25519SigningKeyId),
+			signerSlot: Number(identity.signer.signerSlot)
+		},
+		auth: canonicalAuthBinding(identity.auth),
+		walletSessionId: String(identity.walletSessionId),
+		quotaId: String(identity.quotaId),
+		thresholdSessionId: String(identity.thresholdSessionId)
+	};
+}
+function exactSigningLaneIdentityKey(identity) {
+	return alphabetizeStringify(canonicalExactSigningLaneIdentity(identity));
+}
+function exactEd25519SigningLaneIdentity(lane) {
+	return {
+		kind: "exact_signing_lane",
+		signer: lane.signer,
+		auth: lane.auth,
+		walletSessionId: SigningSessionIds.walletSession(lane.walletSessionId),
+		quotaId: SigningSessionIds.walletSessionQuota(lane.quotaId),
+		thresholdSessionId: SigningSessionIds.thresholdEd25519Session(lane.thresholdSessionId)
+	};
+}
+function exactEd25519ExportMaterialIdentity(lane) {
+	return {
+		kind: "exact_ed25519_export_material",
+		signer: lane.signer,
+		auth: lane.auth,
+		thresholdSessionId: SigningSessionIds.thresholdEd25519Session(lane.thresholdSessionId)
+	};
+}
+function exactEcdsaSigningLaneIdentity(lane) {
+	return {
+		kind: "exact_signing_lane",
+		signer: lane.signer,
+		auth: lane.auth
+	};
+}
+function exactSigningLaneIdentityFromSelectedLane(lane) {
+	return lane.identity;
+}
+function exactEd25519SigningLaneIdentityFromSelectedLane(lane) {
+	return lane.identity;
+}
+function exactEcdsaSigningLaneIdentityFromSelectedLane(lane) {
+	return lane.identity;
+}
+function parseExactEd25519ExportMaterialIdentity(value) {
+	const lane = requireRecord(value, "exact Ed25519 export material identity");
+	if (lane.kind !== "exact_ed25519_export_material") throw new Error("[SigningSession] expected exact Ed25519 export material identity");
+	rejectPresent(lane, [
+		"walletSessionId",
+		"quotaId",
+		"walletId",
+		"nearAccountId",
+		"nearEd25519SigningKeyId",
+		"chainTarget",
+		"keyHandle",
+		"key",
+		"curve",
+		"chainFamily",
+		"accountId",
+		"subjectId",
+		"authMethod",
+		"authorization"
+	], "nested");
+	const signer = nearEd25519SignerBindingFromRaw(requireRecord(lane.signer, "exact Ed25519 export material signer"));
+	if (!signer.ok) throw new Error(signer.error.message);
+	return exactEd25519ExportMaterialIdentity({
+		signer: signer.value,
+		auth: parseSigningLaneAuthBinding(lane.auth),
+		thresholdSessionId: lane.thresholdSessionId
+	});
+}
+function parseExactEcdsaSigningLaneIdentity(value) {
+	const identity = parseExactSigningLaneIdentity(value);
+	if (isExactEcdsaSigningLaneIdentity(identity)) return identity;
+	throw new Error("[SigningSession] expected exact ECDSA lane identity");
+}
+function parseExactSigningLaneIdentity(value) {
+	const lane = requireRecord(value, "exact signing lane identity");
+	if (lane.kind !== "exact_signing_lane") throw new Error("[SigningSession] expected exact signing lane identity");
+	rejectPresent(lane, [
+		"walletId",
+		"nearAccountId",
+		"nearEd25519SigningKeyId",
+		"chainTarget",
+		"keyHandle",
+		"key",
+		"curve",
+		"chainFamily",
+		"accountId",
+		"subjectId",
+		"authMethod",
+		"authorization"
+	], "nested");
+	const signerRecord = requireRecord(lane.signer, "exact lane signer");
+	const auth = parseSigningLaneAuthBinding(lane.auth);
+	switch (signerRecord.kind) {
+		case "near_ed25519_signer": {
+			const signer = nearEd25519SignerBindingFromRaw(signerRecord);
+			if (!signer.ok) throw new Error(signer.error.message);
+			return exactEd25519SigningLaneIdentity({
+				signer: signer.value,
+				auth,
+				walletSessionId: lane.walletSessionId,
+				quotaId: lane.quotaId,
+				thresholdSessionId: lane.thresholdSessionId
+			});
+		}
+		case "evm_family_ecdsa_signer": return exactEcdsaSigningLaneIdentity({
+			signer: parseEvmFamilyEcdsaSignerBinding(signerRecord),
+			auth
+		});
+		default: throw new Error("[SigningSession] exact signing lane signer kind is unsupported");
+	}
+}
+function isExactEcdsaSigningLaneIdentity(identity) {
+	return identity.signer.kind === "evm_family_ecdsa_signer";
+}
+function exactSigningLaneWalletId(identity) {
+	switch (identity.signer.kind) {
+		case "near_ed25519_signer": return identity.signer.account.wallet.walletId;
+		case "evm_family_ecdsa_signer": return identity.signer.walletId;
+		default: return assertNeverExactLane(identity.signer);
+	}
+}
+function requireEvmFamilyEcdsaSigner(identity, context) {
+	if (identity.signer.kind !== "evm_family_ecdsa_signer") throw new Error(`[SigningSession] ${context} requires an EVM-family ECDSA signer`);
+	return identity.signer;
+}
+function requireNearEd25519Signer(identity, context) {
+	if (identity.signer.kind !== "near_ed25519_signer") throw new Error(`[SigningSession] ${context} requires a NEAR Ed25519 signer`);
+	return identity.signer;
+}
+function nearProtocolProjectionFromExactLane(identity, context = "NEAR protocol projection") {
+	const signer = requireNearEd25519Signer(identity, context);
+	return {
+		walletId: signer.account.wallet.walletId,
+		nearAccountId: signer.account.nearAccountId,
+		nearEd25519SigningKeyId: signer.nearEd25519SigningKeyId,
+		signerSlot: signer.signerSlot
+	};
+}
+function exactSigningLaneIdentityMatches(left, right) {
+	return exactSigningLaneIdentityKey(left) === exactSigningLaneIdentityKey(right);
+}
+//#endregion
+export { exactEd25519SigningLaneIdentity as a, exactSigningLaneIdentityKey as c, isExactEcdsaSigningLaneIdentity as d, nearEd25519SignerBindingFromBoundaryFields as f, requireEvmFamilyEcdsaSigner as g, parseExactEd25519ExportMaterialIdentity as h, exactEd25519ExportMaterialIdentity as i, exactSigningLaneIdentityMatches as l, parseExactEcdsaSigningLaneIdentity as m, exactEcdsaSigningLaneIdentity as n, exactEd25519SigningLaneIdentityFromSelectedLane as o, nearProtocolProjectionFromExactLane as p, exactEcdsaSigningLaneIdentityFromSelectedLane as r, exactSigningLaneIdentityFromSelectedLane as s, buildEvmFamilyEcdsaSignerBinding as t, exactSigningLaneWalletId as u };

package/dist/esm/sdk/{export-viewer-host-CbqG8ZQV.js → export-viewer-host-ZqA2Yz3H.js}

@@ -1,5 +1,5 @@
-import { O as resolveUiAppearance, k as sameSurfaceMeasurementBinding } from "./adapters-m94YFj70.js";
-import { t as createWalletIframeSurfaceMeasurementReporter } from "./surface-measurement-reporter-D7BNehf4.js";
+import { O as resolveUiAppearance, k as sameSurfaceMeasurementBinding } from "./adapters-B4JeK1nJ.js";
+import { t as createWalletIframeSurfaceMeasurementReporter } from "./surface-measurement-reporter-CSTyRsMa.js";
 //#region src/core/signingEngine/uiConfirm/ui/export-viewer-host.ts
 let mountedHost = null;
 let mountVersion = 0;
@@ -179,7 +179,7 @@ async function upsertExportViewerHost(args) {
 		id
 	} : { kind: "untracked" };
 	const context = exportContext(args);
-	const { mountExportPrivateKeySurface } = await import("./mountExportPrivateKeySurface-CNc6Mch4.js");
+	const { mountExportPrivateKeySurface } = await import("./mountExportPrivateKeySurface-DgX-IBG_.js");
 	if (version !== mountVersion) return;
 	if (mountedHost?.matches(session, context)) {
 		mountedHost.update(model, args.surfaceMeasurementBinding, args.onLifecycle);

package/dist/esm/sdk/{helpers-DpRjHMBx.js → helpers-ZrowMnev.js}

@@ -1,13 +1,10 @@
-import { l as isString, o as isObject, r as isArray } from "./validation-BphUDXs7.js";
+import { n as asRecordOrArray, p as isString, s as isArray, u as isObject } from "./validation-gat4LEKm.js";
 import { i as base64UrlEncode } from "./base64-Clm8C-e9.js";
-import { n as PASSKEY_PRF_SECOND_SALT_V1, t as PASSKEY_PRF_FIRST_SALT_V1 } from "./signingSessionSeal-CdtgXHSL.js";
+import { n as PASSKEY_PRF_SECOND_SALT_V1, t as PASSKEY_PRF_FIRST_SALT_V1 } from "./signingSessionSeal-Cu-GHm6y.js";
 //#region src/core/signingEngine/webauthnAuth/credentials/credentialExtensions.ts
-function asRecord(value) {
-	return value && typeof value === "object" ? value : null;
-}
 function getPrfResultsFromCredential(credential) {
 	try {
-		const results = asRecord(asRecord(asRecord(asRecord(credential)?.clientExtensionResults)?.prf)?.results);
+		const results = asRecordOrArray(asRecordOrArray(asRecordOrArray(asRecordOrArray(credential)?.clientExtensionResults)?.prf)?.results);
 		if (!results) return {};
 		const first = typeof results.first === "string" ? results.first.trim() : "";
 		const second = typeof results.second === "string" ? results.second.trim() : "";