@seams/wallet 0.6.2 → 0.7.3

package/dist/{public/sdk/signNear-DVD9-IO5.js → esm/sdk/signNear-Bmb2fj_a.js}

@@ -1,41 +1,42 @@
 import { n as __exportAll } from "./chunk-BtrIJ4_z.js";
-import { r as reviewAdmissionForBinding } from "./transactionReviewAdmission-Cv9kTr4c.js";
-import { M as parseThresholdEd25519SessionId, c as normalizeTrimmedString, l as stripTrailingSlashes, p as mpcMaterialActivationRefsEqual } from "./normalize-BephcEIF.js";
-import { C as base58Encode, S as base58Decode, h as ensureEd25519Prefix, o as isObject, s as isPlainObject, t as assertString } from "./validation-BphUDXs7.js";
+import { B as normalizeTrimmedString, S as parseThresholdEd25519SessionId, V as stripTrailingSlashes, r as mpcMaterialActivationRefsEqual } from "./domainIds-lcrFg6Sa.js";
+import { M as base58Encode, _ as requireRecord, d as isPlainObject, i as coerceNonEmptyString, j as base58Decode, r as assertString, u as isObject, w as ensureEd25519Prefix } from "./validation-gat4LEKm.js";
+import { r as reviewAdmissionForBinding } from "./transactionReviewAdmission-BCPvl8OZ.js";
 import { t as errorMessage } from "./errors-93h9uAW9.js";
 import { i as base64UrlEncode, n as base64Encode, r as base64UrlDecode } from "./base64-Clm8C-e9.js";
 import { n as secureRandomBase64Url } from "./secureRandomId-BORsmdS4.js";
-import { A as alphabetizeStringify, I as parseDigestB64u, J as resolvePrimaryNearRpcUrl, K as resolveNearNetwork, M as sha256BytesUtf8 } from "./registrationIntent-DwAIMQYh.js";
-import { a as thresholdEcdsaChainTargetFromRequest, c as toWalletId } from "./ecdsaChainTarget-BOTPGIU_.js";
-import { n as SIGNER_AUTH_METHODS, t as SENSITIVE_OPERATION_POLICIES } from "./signerDomain-DDLiwuYS.js";
-import { r as normalizeThresholdEd25519ParticipantIds } from "./participants-Bcnsa_ip.js";
-import { t as toAccountId } from "./accountIds-Ck4GAQfm.js";
-import { o as normalizeThresholdRuntimePolicyScope } from "./sessionPolicy-B4FsPuk2.js";
-import { Ht as walletAuthAuthorityRef, R as parseWalletSessionOperationCredentialV1, Rt as parsePasskeyWalletAuthAuthority } from "./ecdsaPresignLifecycle-CnSnzoRJ.js";
-import { c as parseCapabilityOperationId, d as parseMpcWalletSigningQuotaId, f as parsePrincipalId, h as parseWalletSessionId, m as parseWalletSessionAuthorizationId, p as parseTenantId, s as parseCapabilityId } from "./capabilityKinds-jwCEaqBU.js";
-import { A as signingLaneAuthBindingKey, D as SigningSessionPlanKind, E as SigningSessionIds, L as exactEd25519SigningLaneIdentityFromSelectedLane, O as summarizeSigningLane, T as SigningOperationIntent, U as nearEd25519SignerBindingFromBoundaryFields, j as signingLaneAuthMethod, k as summarizeSigningSessionPlan, w as SigningKeyRefIntentKind, x as toRpId, z as exactSigningLaneIdentityKey } from "./evmFamilyEcdsaIdentity-_kuKSW35.js";
-import { a as SIGNING_SESSION_EXPIRY_DETECTION_SOURCES, m as createSigningFlowEvent, o as SigningEventPhase } from "./sdkSentEvents-5Pi-hjHB.js";
-import { t as parseSignerSlot } from "./signerSlot-DbNAs-kc.js";
-import { i as ROUTER_AB_ED25519_WALLET_SESSION_PATH } from "./signingSessionSeal-CdtgXHSL.js";
-import { o as toEmailOtpAuthSubjectId, t as demoEmailOtpCodeFromDelivery } from "./challengeDelivery-BjLKoou3.js";
-import { t as executeWorkerOperation } from "./executeWorkerOperation-Bn8GEuT_.js";
-import { a as normalizeRegistrationCredential, i as normalizeAuthenticationCredential, l as getPrfFirstB64uFromCredential, u as redactCredentialExtensionOutputs } from "./helpers-DpRjHMBx.js";
-import { p as nonceLeaseToRef } from "./nonceLaneKeys-B_RcSS6M.js";
-import { i as buildNearAccountRefs, n as resolveProfileAccountContextFromCandidates } from "./profileAccountProjection-C9rVhbeJ.js";
-import { i as WorkerResponseType, n as NearSignerWorkerCustomRequestType, r as WorkerRequestType } from "./signer-worker-DYRteieu.js";
-import { s as parseWalletSessionAlreadyCommittedResponseV1, t as nearEd25519YaoMaterialActivationFromMetadata, y as fundImplicitNearAccountForTesting } from "./nearEd25519YaoMaterialActivation-Cz5UJQ_7.js";
-import { n as buildRelayerJsonPostRequestInit, t as buildBearerAuthorizationHeader } from "./relayerHttp-LsVTZCxA.js";
-import { s as buildNearTransactionSigningLane } from "./nearEd25519YaoSigningPreparation-DX6xG-IW.js";
-import { n as computeCapabilityOperationFingerprintDigest, r as parseSigningOperationFingerprintDigest, t as buildCapabilityOperationEnvelope } from "./operationFingerprint-CsYO6b0a.js";
-import { a as emitEd25519SigningTiming, c as emitSigningPlannerDecisionTrace, o as emitSigningBoundaryTrace, s as emitSigningLaneResolutionTrace, t as createSigningBoundaryTraceEvent } from "./trace-08ayoiNp.js";
-import { a as toActionArgsWasm, n as fromActionArgsWasm, o as validateActionArgsWasm, t as ActionType } from "./actions-DsBQcjBn.js";
-import { n as SignedTransaction } from "./NearClient-BQgcqAzG.js";
-import { n as PASSKEY_MANAGER_DEFAULT_CONFIGS } from "./defaultConfigs-CyNOW4Sy.js";
-import { n as buildNearNonceLane } from "./NonceCoordinator-C7mqpJiU.js";
-import { a as isPasskeySigningAuthPlan, i as isEmailOtpSigningAuthPlan, n as SigningAuthPlanKind, o as isWarmSessionSigningAuthPlan } from "./promptText-BEgOkGxB.js";
-import { S as isSigningOperationReviewApprovedState, _ as SigningOperationCommandKind, c as runSigningConfirmationCommand, g as prepareStepUpAuth, h as buildSigningConfirmationAuthParams, l as runTransactionSigningConfirmationCommand, n as confirmationConfigForSigningAuthPlan, o as mapSigningConfirmationProgress, s as resolveSigningConfirmationAuthMethod, u as signingAuthPlanFromSigningSessionPlan, w as runSigningOperationCommand, x as createSigningOperationStateRef } from "./operationFingerprint-DEPg9A3h.js";
-import { C as waitForWalletSessionQuotaAdmissionRetry, S as decideWalletSessionQuotaAdmissionFailure, a as buildRouterAbEd25519NormalSigningFinalizeRequestV2, b as buildWalletSessionQuotaAdmissionQueueKey, d as routerAbCanonicalWireBytesToB64u, f as routerAbNormalSigningActionFingerprint, g as walletSessionFailureFromError, i as buildRouterAbEd25519Nep413PrepareRequestV2, n as buildRouterAbEd25519DelegateActionPrepareRequestV2, r as buildRouterAbEd25519NearTransactionPrepareRequestV2, s as finalizeRouterAbNormalSigningV2, u as prepareRouterAbNormalSigningV2, v as WalletSessionQuotaAdmissionError, x as classifyWalletSessionQuotaAdmissionFailure } from "./routerAbNormalSigning-DktZKnf1.js";
-import { a as recordAvailableSigningLanesRead, b as withThresholdCommitQueue, c as selectTransactionLaneFromAvailableLanes, i as receiveTransactionIntent, n as prepareTransactionOperationFromReadiness, r as prepareTransactionSigningOperation, s as selectNearEd25519MaterialCandidate, t as classifyTransactionReadiness, v as requireAuthoritativeExpiredWalletSessionAuthorizationBoundary } from "./transactionState-Bpm4GamO.js";
+import { d as normalizeThresholdEd25519ParticipantIds, o as normalizeThresholdRuntimePolicyScope } from "./sessionPolicy-DO-MkL65.js";
+import { et as parsePasskeyWalletAuthAuthority, it as walletAuthAuthorityRef, jt as parseWalletSessionOperationCredentialV1 } from "./ecdsaPresignLifecycle-Bfx2AQKb.js";
+import { c as parseCapabilityOperationId, d as parseMpcWalletSigningQuotaId, f as parsePrincipalId, h as parseWalletSessionId, m as parseWalletSessionAuthorizationId, p as parseTenantId, s as parseCapabilityId } from "./capabilityKinds-hvYqa6S_.js";
+import { d as resolvePrimaryNearRpcUrl, f as alphabetizeStringify, l as resolveNearNetwork, m as sha256BytesUtf8 } from "./chains-BMh3btVo.js";
+import { r as parseDigestB64u } from "./canonicalPrimitives-BTHWz80v.js";
+import { a as thresholdEcdsaChainTargetFromRequest, c as toWalletId } from "./ecdsaChainTarget-Bl-JWyuw.js";
+import { n as SIGNER_AUTH_METHODS, t as SENSITIVE_OPERATION_POLICIES } from "./signerDomain-IEAVrOrc.js";
+import { t as toAccountId } from "./accountIds-DhIPGOSN.js";
+import { x as toRpId } from "./evmFamilyEcdsaIdentity-CqGafQsI.js";
+import { a as SIGNING_SESSION_EXPIRY_DETECTION_SOURCES, m as createSigningFlowEvent, o as SigningEventPhase } from "./sdkSentEvents-MqDkbQg1.js";
+import { t as parseSignerSlot } from "./signerSlot-_ovonwVX.js";
+import { i as ROUTER_AB_ED25519_WALLET_SESSION_PATH } from "./signingSessionSeal-Cu-GHm6y.js";
+import { a as summarizeSigningLane, c as signingLaneAuthMethod, i as SigningSessionPlanKind, n as SigningOperationIntent, o as summarizeSigningSessionPlan, r as SigningSessionIds, s as signingLaneAuthBindingKey, t as SigningKeyRefIntentKind } from "./types-Dx9fczU7.js";
+import { o as toEmailOtpAuthSubjectId, t as demoEmailOtpCodeFromDelivery } from "./challengeDelivery-DZtopOAG.js";
+import { t as executeWorkerOperation } from "./executeWorkerOperation-Cl9whMK7.js";
+import { a as normalizeRegistrationCredential, i as normalizeAuthenticationCredential, l as getPrfFirstB64uFromCredential, u as redactCredentialExtensionOutputs } from "./helpers-ZrowMnev.js";
+import { p as nonceLeaseToRef } from "./nonceLaneKeys-C3c9lG6u.js";
+import { i as buildNearAccountRefs, n as resolveProfileAccountContextFromCandidates } from "./profileAccountProjection-uZVJuBvS.js";
+import { b as fundImplicitNearAccountForTesting, s as parseWalletSessionAlreadyCommittedResponseV1, t as nearEd25519YaoMaterialActivationFromMetadata } from "./nearEd25519YaoMaterialActivation-B5GecIvq.js";
+import { n as buildRelayerJsonPostRequestInit, t as buildBearerAuthorizationHeader } from "./relayerHttp-VC8Holz1.js";
+import { c as exactSigningLaneIdentityKey, f as nearEd25519SignerBindingFromBoundaryFields, o as exactEd25519SigningLaneIdentityFromSelectedLane } from "./exactSigningLaneIdentity-m6uTXV_A.js";
+import { s as buildNearTransactionSigningLane } from "./nearEd25519YaoSigningPreparation-CdOT5RuC.js";
+import { n as computeCapabilityOperationFingerprintDigest, r as parseSigningOperationFingerprintDigest, t as buildCapabilityOperationEnvelope } from "./operationFingerprint-CGZui5dR.js";
+import { a as emitEd25519SigningTiming, c as emitSigningPlannerDecisionTrace, o as emitSigningBoundaryTrace, s as emitSigningLaneResolutionTrace, t as createSigningBoundaryTraceEvent } from "./trace-DKLQZvec.js";
+import { a as toActionArgsWasm, n as fromActionArgsWasm, o as validateActionArgsWasm, t as ActionType } from "./actions-CCvThiKe.js";
+import { n as SignedTransaction } from "./NearClient-DY4NfHeD.js";
+import { n as PASSKEY_MANAGER_DEFAULT_CONFIGS } from "./defaultConfigs-D_33pPT9.js";
+import { n as buildNearNonceLane } from "./NonceCoordinator-4XWPhYww.js";
+import { a as isPasskeySigningAuthPlan, i as isEmailOtpSigningAuthPlan, n as SigningAuthPlanKind, o as isWarmSessionSigningAuthPlan } from "./promptText-CuRa_ivd.js";
+import { S as isSigningOperationReviewApprovedState, _ as SigningOperationCommandKind, c as runSigningConfirmationCommand, g as prepareStepUpAuth, h as buildSigningConfirmationAuthParams, l as runTransactionSigningConfirmationCommand, n as confirmationConfigForSigningAuthPlan, o as mapSigningConfirmationProgress, s as resolveSigningConfirmationAuthMethod, u as signingAuthPlanFromSigningSessionPlan, w as runSigningOperationCommand, x as createSigningOperationStateRef } from "./operationFingerprint-C8Trar4R.js";
+import { S as waitForWalletSessionQuotaAdmissionRetry, _ as WalletSessionQuotaAdmissionError, a as buildRouterAbEd25519NormalSigningFinalizeRequestV2, b as classifyWalletSessionQuotaAdmissionFailure, d as routerAbNormalSigningActionFingerprint, h as walletSessionFailureFromError, i as buildRouterAbEd25519Nep413PrepareRequestV2, l as prepareRouterAbNormalSigningV2, n as buildRouterAbEd25519DelegateActionPrepareRequestV2, r as buildRouterAbEd25519NearTransactionPrepareRequestV2, s as finalizeRouterAbNormalSigningV2, u as routerAbCanonicalWireBytesToB64u, x as decideWalletSessionQuotaAdmissionFailure, y as buildWalletSessionQuotaAdmissionQueueKey } from "./routerAbNormalSigning-CVFEOZ2m.js";
+import { C as withThresholdCommitQueue, S as resolveThresholdCommitQueueKey, a as recordAvailableSigningLanesRead, b as requireAuthoritativeExpiredWalletSessionAuthorizationBoundary, c as selectTransactionLaneFromAvailableLanes, i as receiveTransactionIntent, n as prepareTransactionOperationFromReadiness, r as prepareTransactionSigningOperation, s as selectNearEd25519MaterialCandidate, t as classifyTransactionReadiness } from "./transactionState-CJ4U8pcl.js";
 //#region src/core/platform/secretSources.ts
 const clientSecretSourceBrand = Symbol("ClientSecretSource");
 const emailOtpWorkerSessionHandleBrand = Symbol("EmailOtpWorkerSessionHandle");
@@ -141,6 +142,53 @@ function parseEmailOtpEcdsaExportWorkerIssuedSessionHandle(input) {
 	return handle;
 }
 //#endregion
+//#region src/core/types/signer-worker.ts
+let WorkerRequestType = /* @__PURE__ */ function(WorkerRequestType) {
+	WorkerRequestType[WorkerRequestType["SignTransactionsWithActions"] = 0] = "SignTransactionsWithActions";
+	WorkerRequestType[WorkerRequestType["SignNep413Message"] = 1] = "SignNep413Message";
+	WorkerRequestType[WorkerRequestType["SignDelegateAction"] = 2] = "SignDelegateAction";
+	WorkerRequestType[WorkerRequestType["DeriveThresholdEd25519ClientVerifyingShare"] = 3] = "DeriveThresholdEd25519ClientVerifyingShare";
+	return WorkerRequestType;
+}({});
+let WorkerResponseType = /* @__PURE__ */ function(WorkerResponseType) {
+	WorkerResponseType[WorkerResponseType["SignTransactionsWithActionsSuccess"] = 0] = "SignTransactionsWithActionsSuccess";
+	WorkerResponseType[WorkerResponseType["SignNep413MessageSuccess"] = 1] = "SignNep413MessageSuccess";
+	WorkerResponseType[WorkerResponseType["SignDelegateActionSuccess"] = 2] = "SignDelegateActionSuccess";
+	WorkerResponseType[WorkerResponseType["SignTransactionsWithActionsFailure"] = 3] = "SignTransactionsWithActionsFailure";
+	WorkerResponseType[WorkerResponseType["SignNep413MessageFailure"] = 4] = "SignNep413MessageFailure";
+	WorkerResponseType[WorkerResponseType["SignDelegateActionFailure"] = 5] = "SignDelegateActionFailure";
+	WorkerResponseType[WorkerResponseType["RegistrationProgress"] = 6] = "RegistrationProgress";
+	WorkerResponseType[WorkerResponseType["RegistrationComplete"] = 7] = "RegistrationComplete";
+	WorkerResponseType[WorkerResponseType["ExecuteActionsProgress"] = 8] = "ExecuteActionsProgress";
+	WorkerResponseType[WorkerResponseType["ExecuteActionsComplete"] = 9] = "ExecuteActionsComplete";
+	WorkerResponseType[WorkerResponseType["DeriveThresholdEd25519ClientVerifyingShareSuccess"] = 10] = "DeriveThresholdEd25519ClientVerifyingShareSuccess";
+	WorkerResponseType[WorkerResponseType["DeriveThresholdEd25519ClientVerifyingShareFailure"] = 11] = "DeriveThresholdEd25519ClientVerifyingShareFailure";
+	return WorkerResponseType;
+}({});
+const NearSignerWorkerCustomRequestType = {
+	ThresholdEd25519ComputeNep413SigningDigest: "thresholdEd25519ComputeNep413SigningDigest",
+	ThresholdEd25519ComputeDelegateSigningDigest: "thresholdEd25519ComputeDelegateSigningDigest",
+	ThresholdEd25519BuildDelegateSigningPayload: "thresholdEd25519BuildDelegateSigningPayload",
+	ThresholdEd25519FinalizeDelegateFromSignature: "thresholdEd25519FinalizeDelegateFromSignature",
+	ThresholdEd25519FinalizeNearTxFromSignature: "thresholdEd25519FinalizeNearTxFromSignature",
+	ThresholdEd25519BuildNearTxUnsignedBorsh: "thresholdEd25519BuildNearTxUnsignedBorsh",
+	ThresholdEd25519DecodeSignedNearTxBorsh: "thresholdEd25519DecodeSignedNearTxBorsh"
+};
+const DEFAULT_CONFIRMATION_CONFIG = {
+	uiMode: "modal",
+	behavior: "requireClick",
+	autoProceedDelay: 0
+};
+function isWorkerProgress(response) {
+	return response.type === WorkerResponseType.RegistrationProgress || response.type === WorkerResponseType.RegistrationComplete || response.type === WorkerResponseType.ExecuteActionsProgress || response.type === WorkerResponseType.ExecuteActionsComplete;
+}
+function isWorkerSuccess(response) {
+	return response.type === WorkerResponseType.SignTransactionsWithActionsSuccess || response.type === WorkerResponseType.SignDelegateActionSuccess || response.type === WorkerResponseType.SignNep413MessageSuccess || response.type === WorkerResponseType.DeriveThresholdEd25519ClientVerifyingShareSuccess;
+}
+function isWorkerError(response) {
+	return response.type === WorkerResponseType.SignTransactionsWithActionsFailure || response.type === WorkerResponseType.SignDelegateActionFailure || response.type === WorkerResponseType.SignNep413MessageFailure || response.type === WorkerResponseType.DeriveThresholdEd25519ClientVerifyingShareFailure;
+}
+//#endregion
 //#region src/core/signingEngine/chains/near/display.ts
 function toSafeJson(value) {
 	try {
@@ -371,6 +419,19 @@ function buildNearMessageDisplayModel(args) {
 		operations: [operation]
 	};
 }
+function buildNearPreparationDisplayModel(args) {
+	try {
+		return buildNearDisplayModel(args);
+	} catch {
+		return {
+			chain: "near",
+			signerAccount: args.signerAccount,
+			...args.title ? { title: args.title } : {},
+			...args.subtitle ? { subtitle: args.subtitle } : {},
+			operations: []
+		};
+	}
+}
 //#endregion
 //#region src/core/signingEngine/webauthnAuth/device/signerSlot.ts
 /**
@@ -482,8 +543,8 @@ async function thresholdEd25519NearTransactionOperationFingerprint(input) {
 			purpose: "near_transaction",
 			...canonicalScope(input),
 			transactions: canonicalNearTransactions(input.transactions),
-			unsignedTransactionBorshB64u: requiredString(input.unsignedTransactionBorshB64u, "unsignedTransactionBorshB64u"),
-			signingDigestB64u: requiredString(input.signingDigestB64u, "signingDigestB64u")
+			unsignedTransactionBorshB64u: coerceNonEmptyString(input.unsignedTransactionBorshB64u, "unsignedTransactionBorshB64u"),
+			signingDigestB64u: coerceNonEmptyString(input.signingDigestB64u, "signingDigestB64u")
 		}
 	});
 }
@@ -493,9 +554,9 @@ async function thresholdEd25519Nep413OperationFingerprint(input) {
 		payload: {
 			purpose: "nep413_message",
 			...canonicalScope(input),
-			message: requiredString(input.message, "message"),
-			recipient: requiredString(input.recipient, "recipient"),
-			nonce: requiredString(input.nonce, "nonce"),
+			message: coerceNonEmptyString(input.message, "message"),
+			recipient: coerceNonEmptyString(input.recipient, "recipient"),
+			nonce: coerceNonEmptyString(input.nonce, "nonce"),
 			state: input.state ? String(input.state) : null
 		}
 	});
@@ -512,16 +573,16 @@ async function thresholdEd25519DelegateActionOperationFingerprint(input) {
 }
 async function thresholdEd25519OperationFingerprint(input) {
 	return `sha256:${base64UrlEncode(await sha256BytesUtf8(alphabetizeStringify({
-		kind: requiredString(input.kind, "kind"),
+		kind: coerceNonEmptyString(input.kind, "kind"),
 		payload: normalizeFingerprintValue(input.payload)
 	})))}`;
 }
 function canonicalScope(input) {
 	return {
-		nearAccountId: requiredString(input.nearAccountId, "nearAccountId"),
-		nearNetworkId: requiredString(input.nearNetworkId, "nearNetworkId"),
-		relayerKeyId: requiredString(input.relayerKeyId, "relayerKeyId"),
-		signerPublicKey: requiredString(input.signerPublicKey, "signerPublicKey")
+		nearAccountId: coerceNonEmptyString(input.nearAccountId, "nearAccountId"),
+		nearNetworkId: coerceNonEmptyString(input.nearNetworkId, "nearNetworkId"),
+		relayerKeyId: coerceNonEmptyString(input.relayerKeyId, "relayerKeyId"),
+		signerPublicKey: coerceNonEmptyString(input.signerPublicKey, "signerPublicKey")
 	};
 }
 function canonicalNearTransactions(transactions) {
@@ -530,19 +591,19 @@ function canonicalNearTransactions(transactions) {
 }
 function canonicalDelegate(delegate) {
 	return {
-		senderId: requiredString(delegate.senderId, "delegate.senderId"),
-		receiverId: requiredString(delegate.receiverId, "delegate.receiverId"),
+		senderId: coerceNonEmptyString(delegate.senderId, "delegate.senderId"),
+		receiverId: coerceNonEmptyString(delegate.receiverId, "delegate.receiverId"),
 		actions: canonicalActions(delegate.actions, "delegate.actions"),
-		nonce: requiredString(delegate.nonce, "delegate.nonce"),
-		maxBlockHeight: requiredString(delegate.maxBlockHeight, "delegate.maxBlockHeight"),
-		publicKey: requiredString(delegate.publicKey, "delegate.publicKey")
+		nonce: coerceNonEmptyString(delegate.nonce, "delegate.nonce"),
+		maxBlockHeight: coerceNonEmptyString(delegate.maxBlockHeight, "delegate.maxBlockHeight"),
+		publicKey: coerceNonEmptyString(delegate.publicKey, "delegate.publicKey")
 	};
 }
 function parseThresholdEd25519NearTransaction(raw, label) {
 	const record = requireRecord(raw, label);
 	return {
-		nearAccountId: requiredString(record.nearAccountId, `${label}.nearAccountId`),
-		receiverId: requiredString(record.receiverId, `${label}.receiverId`),
+		nearAccountId: coerceNonEmptyString(record.nearAccountId, `${label}.nearAccountId`),
+		receiverId: coerceNonEmptyString(record.receiverId, `${label}.receiverId`),
 		actions: canonicalActions(record.actions, `${label}.actions`)
 	};
 }
@@ -552,7 +613,7 @@ function canonicalActions(actions, label) {
 }
 function parseThresholdEd25519NearAction(action, label) {
 	const record = requireRecord(action, label);
-	const actionType = requiredString(record.action_type, `${label}.action_type`);
+	const actionType = coerceNonEmptyString(record.action_type, `${label}.action_type`);
 	switch (actionType) {
 		case "CreateAccount": return { action_type: actionType };
 		case "DeployContract": return {
@@ -561,32 +622,32 @@ function parseThresholdEd25519NearAction(action, label) {
 		};
 		case "FunctionCall": return {
 			action_type: actionType,
-			method_name: requiredString(record.method_name, `${label}.method_name`),
-			args: requiredString(record.args, `${label}.args`),
-			gas: requiredString(record.gas, `${label}.gas`),
-			deposit: requiredString(record.deposit, `${label}.deposit`)
+			method_name: coerceNonEmptyString(record.method_name, `${label}.method_name`),
+			args: coerceNonEmptyString(record.args, `${label}.args`),
+			gas: coerceNonEmptyString(record.gas, `${label}.gas`),
+			deposit: coerceNonEmptyString(record.deposit, `${label}.deposit`)
 		};
 		case "Transfer": return {
 			action_type: actionType,
-			deposit: requiredString(record.deposit, `${label}.deposit`)
+			deposit: coerceNonEmptyString(record.deposit, `${label}.deposit`)
 		};
 		case "Stake": return {
 			action_type: actionType,
-			stake: requiredString(record.stake, `${label}.stake`),
-			public_key: requiredString(record.public_key, `${label}.public_key`)
+			stake: coerceNonEmptyString(record.stake, `${label}.stake`),
+			public_key: coerceNonEmptyString(record.public_key, `${label}.public_key`)
 		};
 		case "AddKey": return {
 			action_type: actionType,
-			public_key: requiredString(record.public_key, `${label}.public_key`),
-			access_key: requiredString(record.access_key, `${label}.access_key`)
+			public_key: coerceNonEmptyString(record.public_key, `${label}.public_key`),
+			access_key: coerceNonEmptyString(record.access_key, `${label}.access_key`)
 		};
 		case "DeleteKey": return {
 			action_type: actionType,
-			public_key: requiredString(record.public_key, `${label}.public_key`)
+			public_key: coerceNonEmptyString(record.public_key, `${label}.public_key`)
 		};
 		case "DeleteAccount": return {
 			action_type: actionType,
-			beneficiary_id: requiredString(record.beneficiary_id, `${label}.beneficiary_id`)
+			beneficiary_id: coerceNonEmptyString(record.beneficiary_id, `${label}.beneficiary_id`)
 		};
 		case "SignedDelegate": return {
 			action_type: actionType,
@@ -605,8 +666,8 @@ function parseThresholdEd25519NearAction(action, label) {
 function parseThresholdEd25519SignedDelegateAction(raw, label) {
 	const record = requireRecord(raw, label);
 	return {
-		senderId: requiredString(record.senderId, `${label}.senderId`),
-		receiverId: requiredString(record.receiverId, `${label}.receiverId`),
+		senderId: coerceNonEmptyString(record.senderId, `${label}.senderId`),
+		receiverId: coerceNonEmptyString(record.receiverId, `${label}.receiverId`),
 		actions: canonicalActions(record.actions, `${label}.actions`),
 		nonce: requiredIntegerLike(record.nonce, `${label}.nonce`),
 		maxBlockHeight: requiredIntegerLike(record.maxBlockHeight, `${label}.maxBlockHeight`),
@@ -655,22 +716,13 @@ function requiredSafeInteger(value, label) {
 function requiredIntegerLike(value, label) {
 	if (typeof value === "bigint") return value;
 	if (typeof value === "number" && Number.isSafeInteger(value)) return value;
-	return requiredString(value, label);
+	return coerceNonEmptyString(value, label);
 }
 function requiredDeployMode(value, label) {
-	const deployMode = requiredString(value, label);
+	const deployMode = coerceNonEmptyString(value, label);
 	if (deployMode === "CodeHash" || deployMode === "AccountId") return deployMode;
 	throw new Error(`${label} is invalid`);
 }
-function requireRecord(value, label) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label} must be an object`);
-	return value;
-}
-function requiredString(value, label) {
-	const normalized = String(value || "").trim();
-	if (!normalized) throw new Error(`${label} is required`);
-	return normalized;
-}
 function optionalString(value) {
 	return String(value || "").trim() || null;
 }
@@ -2707,13 +2759,20 @@ function emitNearSigningEvent$2(onEvent, accountId, event) {
 	} catch {}
 }
 async function requireActiveAuthorizedWalletSessionState(args) {
-	if (!args.state) throw new Error("[SigningEngine][near] reusable Wallet Session state is unavailable");
-	const authorized = await args.coordinator.resolveActiveAuthorizedRouterAbEd25519WalletSessionState({
-		state: args.state,
-		nowMs: Date.now()
-	});
-	if (!authorized) throw new Error("[SigningEngine][near] reusable Wallet Session authorization is unavailable");
-	return authorized;
+	const startedAt = performance.now();
+	let outcome = "failed";
+	try {
+		if (!args.state) throw new Error("[SigningEngine][near] reusable Wallet Session state is unavailable");
+		const authorized = await args.coordinator.resolveActiveAuthorizedRouterAbEd25519WalletSessionState({
+			state: args.state,
+			nowMs: Date.now()
+		});
+		if (!authorized) throw new Error("[SigningEngine][near] reusable Wallet Session authorization is unavailable");
+		outcome = "succeeded";
+		return authorized;
+	} finally {
+		emitEd25519SigningTiming(args.operationId, "wallet_session_authorization", startedAt, outcome);
+	}
 }
 async function prepareNearTransactionConfirmationReadiness(args) {
 	const material = await prepareNearOperationStepUpMaterial({
@@ -2911,10 +2970,7 @@ async function runNearAuthorizationRequiredTransactionSigning(payload) {
 				}),
 				title,
 				body,
-				confirmationReadiness: {
-					promise: operationStepUpReadiness,
-					body: "Preparing secure signing session…"
-				},
+				confirmationReadiness: { promise: operationStepUpReadiness },
 				onProgress: emitNearSigningConfirmationProgress.bind(void 0, {
 					onEvent,
 					nearAccountId,
@@ -3007,6 +3063,7 @@ async function runNearAuthorizationRequiredTransactionSigning(payload) {
 	}
 }
 async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubject, nearAccount, transaction, rpcCall, onEvent, confirmationConfigOverride, title, body, signerSlot, signingOperationState, signingSessionCoordinator: sessionCoordinator, transactionOperation, ed25519SigningBoundary, passkeyEd25519OperationStepUp, emailOtpEd25519StepUp, yaoSigningPreparation, yaoMaterialExecutor }) {
+	const preConfirmationStartedAt = performance.now();
 	const signingOperationId = signingOperationState.operationId;
 	const nearAccountId = toAccountId(nearAccount.accountId);
 	const relayerUrl = ctx.relayerUrl;
@@ -3163,6 +3220,8 @@ async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubj
 			signatureUses: requiredSignatureUses
 		}
 	});
+	emitEd25519SigningTiming(String(signingOperationId), "pre_confirmation", preConfirmationStartedAt);
+	const confirmationStartedAt = performance.now();
 	let confirmation;
 	try {
 		confirmation = await runTransactionSigningConfirmationCommand({
@@ -3198,10 +3257,7 @@ async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubj
 				}),
 				title,
 				body,
-				...operationStepUpReadiness ? { confirmationReadiness: {
-					promise: operationStepUpReadiness,
-					body: "Preparing secure signing session…"
-				} } : {},
+				...operationStepUpReadiness ? { confirmationReadiness: { promise: operationStepUpReadiness } } : {},
 				onProgress: emitUiConfirmProgress
 			}
 		});
@@ -3212,6 +3268,7 @@ async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubj
 		});
 	}
 	const confirmationCompletedAt = performance.now();
+	emitEd25519SigningTiming(String(signingOperationId), "confirmation", confirmationStartedAt);
 	const operationStepUpMaterial = operationStepUpReadiness ? await operationStepUpReadiness : null;
 	if (transactionReviewRequired) emitNearSigningEvent$2(onEvent, nearAccountId, {
 		phase: SigningEventPhase.STEP_05_CONFIRMATION_APPROVED,
@@ -3243,9 +3300,12 @@ async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubj
 		proof: requireNearEd25519OperationStepUpProof(operationStepUpProof)
 	});
 	const ownsResolvedOperationStepUpMaterial = operationStepUpMaterial?.kind === "passkey_sealed" || operationStepUpMaterial?.kind === "email_otp_sealed";
+	const durableLeaseRecoveryWaitStartedAt = performance.now();
 	try {
 		await durableLeaseRecovery;
+		emitEd25519SigningTiming(String(signingOperation.operationId), "durable_lease_recovery_wait", durableLeaseRecoveryWaitStartedAt);
 	} catch (error) {
+		emitEd25519SigningTiming(String(signingOperation.operationId), "durable_lease_recovery_wait", durableLeaseRecoveryWaitStartedAt, "failed");
 		disposeOwnedNearOperationStepUpMaterial({
 			resolved: resolvedOperationStepUpMaterial,
 			owned: ownsResolvedOperationStepUpMaterial
@@ -3265,6 +3325,7 @@ async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubj
 					overlay: "none"
 				}
 			});
+			const materialResolutionStartedAt = performance.now();
 			const resolvedMaterial = stepUpAuthorization.kind === "warm_session" ? {
 				kind: "warm_session",
 				resolved: await requireWarmNearSigningMaterialTask(warmSigningMaterialTask)
@@ -3272,9 +3333,11 @@ async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubj
 				kind: "operation_step_up",
 				resolved: resolvedOperationStepUpMaterial
 			};
+			emitEd25519SigningTiming(String(signingOperation.operationId), "material_resolution_wait", materialResolutionStartedAt);
 			const canonicalThresholdSessionId = resolvedMaterial.kind === "warm_session" ? resolvedMaterial.resolved.material.facts.thresholdSessionId : resolvedMaterial.resolved.material.facts.thresholdSessionId;
 			const activeYaoClient = resolvedMaterial.kind === "warm_session" ? resolvedMaterial.resolved.material.activeClient : resolvedMaterial.resolved.material.activeClient;
 			const activeWalletSessionState = resolvedMaterial.kind === "warm_session" ? resolvedMaterial.resolved.walletSessionState : null;
+			const transactionContextStartedAt = performance.now();
 			const confirmedNearContext = resolvedMaterial.kind === "warm_session" ? await resolveConfirmedNearTransactionContext({
 				confirmation,
 				ctx,
@@ -3286,6 +3349,7 @@ async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubj
 			}) : confirmation.readiness.kind === "context_ready" ? confirmation.readiness : (() => {
 				throw new Error("[SigningEngine][near] operation step-up confirmation did not resolve a transaction context");
 			})();
+			emitEd25519SigningTiming(String(signingOperation.operationId), "transaction_context", transactionContextStartedAt);
 			emitNearSigningEvent$2(onEvent, nearAccountId, {
 				phase: SigningEventPhase.STEP_07_AUTHENTICATION_COMPLETE,
 				status: "succeeded",
@@ -3377,7 +3441,8 @@ async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubj
 			activeClient: yaoClient,
 			walletSessionState: await requireActiveAuthorizedWalletSessionState({
 				state: walletSessionState,
-				coordinator: sessionCoordinator
+				coordinator: sessionCoordinator,
+				operationId: String(signingOperation.operationId)
 			}),
 			thresholdKeyMaterial: signingContext.threshold.thresholdKeyMaterial,
 			walletId: commandSubject.walletSession.walletId,
@@ -3398,13 +3463,17 @@ async function runAuthorizedNearTransactionWithActionsSigning({ ctx, commandSubj
 			try {
 				const okResponse = await executeSignRequest(preparedActiveClient);
 				thresholdSignatureCreated = true;
+				const nonceLeaseCommitStartedAt = performance.now();
 				await markNearNonceLeasesSigned(ctx, nonceLeaseRefs);
+				emitEd25519SigningTiming(String(signingOperation.operationId), "nonce_lease_commit", nonceLeaseCommitStartedAt);
+				const transactionAssemblyStartedAt = performance.now();
 				const signedResult = toSignedTransactionResult({
 					okResponse,
 					nearAccountId,
 					warnings,
 					nonceLeases: nonceLeaseRefs
 				});
+				emitEd25519SigningTiming(String(signingOperation.operationId), "transaction_assembly", transactionAssemblyStartedAt);
 				emitEd25519SigningTiming(String(signingOperation.operationId), "confirmed_to_signed", confirmationCompletedAt);
 				emitNearSigningEvent$2(onEvent, nearAccountId, {
 					phase: SigningEventPhase.STEP_11_TRANSACTION_SIGNED,
@@ -3598,6 +3667,98 @@ function parseAndValidateRegistrationCredentialConfirmationPayload(payload) {
 	};
 }
 //#endregion
+//#region src/core/signingEngine/session/planning/planner.ts
+function planSigningSession(input) {
+	const lane = input.lane;
+	const readiness = input.readiness;
+	if (lane.curve !== readiness.curve) throw new Error("[SigningSession] planner lane and readiness curves do not match");
+	if (lane.curve === "ecdsa" && readiness.curve === "ecdsa") {
+		const laneAuthorization = lane.authorization;
+		const readinessAuthorization = readiness.authorization;
+		const laneSession = laneAuthorization.session;
+		const readinessSession = readinessAuthorization.session;
+		if (!mpcMaterialActivationRefsEqual(lane.materialActivation, readiness.materialActivation) || laneAuthorization.selectedAuthority.authorityId !== readinessAuthorization.selectedAuthority.authorityId || laneAuthorization.selectedAuthMethod.kind !== readinessAuthorization.selectedAuthMethod.kind || laneAuthorization.selectedAuthMethod.walletAuthMethodId !== readinessAuthorization.selectedAuthMethod.walletAuthMethodId || laneSession.walletId !== readinessSession.walletId || laneSession.authorityId !== readinessSession.authorityId || laneSession.authMethodId !== readinessSession.authMethodId || laneSession.authorizationId !== readinessSession.authorizationId || laneSession.quotaId !== readinessSession.quotaId || laneSession.authorityDigestB64u !== readinessSession.authorityDigestB64u || laneSession.authorityRevocationEpoch !== readinessSession.authorityRevocationEpoch || laneAuthorization.operationCredential.walletSessionId !== readinessAuthorization.operationCredential.walletSessionId || laneAuthorization.operationCredential.token !== readinessAuthorization.operationCredential.token) throw new Error("[SigningSession] planner ECDSA readiness authority does not match its lane");
+	}
+	const policyBlock = getPolicyBlock(input);
+	if (policyBlock) return {
+		kind: SigningSessionPlanKind.NotReady,
+		lane,
+		reason: policyBlock
+	};
+	const forceFreshAuth = input.forceFreshAuth || input.sensitiveOperationPolicy === "require_fresh_same_method" || lane.retention === "single_use";
+	if (readiness.status === "ready" && !forceFreshAuth) {
+		if (lane.curve === "ed25519" && readiness.curve === "ed25519") return {
+			kind: SigningSessionPlanKind.WarmSession,
+			lane,
+			keyRef: {
+				kind: SigningKeyRefIntentKind.Cached,
+				curve: "ed25519",
+				thresholdSessionId: readiness.thresholdSessionId
+			}
+		};
+		if (lane.curve !== "ecdsa" || readiness.curve !== "ecdsa") throw new Error("[SigningSession] planner lane and readiness curves do not match");
+		return {
+			kind: SigningSessionPlanKind.WarmSession,
+			lane,
+			keyRef: {
+				kind: SigningKeyRefIntentKind.Cached,
+				curve: "ecdsa",
+				materialActivation: readiness.materialActivation,
+				authorization: readiness.authorization
+			}
+		};
+	}
+	if (readiness.status === "auth_unavailable" || readiness.status === "status_unavailable" || readiness.status === "status_unknown") return {
+		kind: SigningSessionPlanKind.NotReady,
+		lane,
+		reason: readiness.status
+	};
+	if (signingLaneAuthMethod(lane.auth) === "email_otp") return {
+		kind: SigningSessionPlanKind.EmailOtpReauth,
+		lane,
+		challenge: {
+			chainFamily: lane.chainFamily,
+			lane
+		}
+	};
+	if (lane.curve === "ed25519" && readiness.curve === "ed25519") return {
+		kind: SigningSessionPlanKind.PasskeyReauth,
+		lane,
+		reconnect: {
+			lane,
+			curve: "ed25519",
+			thresholdSessionId: readiness.thresholdSessionId
+		}
+	};
+	if (lane.curve !== "ecdsa" || readiness.curve !== "ecdsa") throw new Error("[SigningSession] planner lane and readiness curves do not match");
+	return {
+		kind: SigningSessionPlanKind.PasskeyReauth,
+		lane,
+		reconnect: {
+			lane,
+			curve: "ecdsa",
+			materialActivation: readiness.materialActivation,
+			authorization: readiness.authorization
+		}
+	};
+}
+function createSigningPlannerDecisionTraceEvent(input, plan) {
+	return {
+		event: "signing_planner_decision",
+		readinessStatus: input.readiness.status,
+		forceFreshAuth: Boolean(input.forceFreshAuth),
+		...input.sensitiveOperationPolicy ? { sensitiveOperationPolicy: input.sensitiveOperationPolicy } : {},
+		plan: summarizeSigningSessionPlan(plan),
+		lane: summarizeSigningLane(input.lane),
+		...plan.kind === SigningSessionPlanKind.NotReady ? { reason: plan.reason } : {}
+	};
+}
+function getPolicyBlock(input) {
+	if (signingLaneAuthMethod(input.lane.auth) !== "email_otp") return null;
+	if (input.sensitiveOperationPolicy === "deny_email_otp" || input.sensitiveOperationPolicy === "require_passkey") return "policy_blocked";
+	return null;
+}
+//#endregion
 //#region src/core/signingEngine/flows/signNear/shared/signingSessionAuthMode.ts
 function requireSelectedLaneSubject(args) {
 	const signer = args.selectedLane.identity.signer;
@@ -3728,142 +3889,31 @@ function buildNearSigningSessionAuthPlan(args) {
 	};
 }
 //#endregion
-//#region src/core/signingEngine/session/planning/planner.ts
-function planSigningSession(input) {
-	const lane = input.lane;
-	const readiness = input.readiness;
-	if (lane.curve !== readiness.curve) throw new Error("[SigningSession] planner lane and readiness curves do not match");
-	if (lane.curve === "ecdsa" && readiness.curve === "ecdsa") {
-		const laneAuthorization = lane.authorization;
-		const readinessAuthorization = readiness.authorization;
-		const laneSession = laneAuthorization.session;
-		const readinessSession = readinessAuthorization.session;
-		if (!mpcMaterialActivationRefsEqual(lane.materialActivation, readiness.materialActivation) || laneAuthorization.selectedAuthority.authorityId !== readinessAuthorization.selectedAuthority.authorityId || laneAuthorization.selectedAuthMethod.kind !== readinessAuthorization.selectedAuthMethod.kind || laneAuthorization.selectedAuthMethod.walletAuthMethodId !== readinessAuthorization.selectedAuthMethod.walletAuthMethodId || laneSession.walletId !== readinessSession.walletId || laneSession.authorityId !== readinessSession.authorityId || laneSession.authMethodId !== readinessSession.authMethodId || laneSession.authorizationId !== readinessSession.authorizationId || laneSession.quotaId !== readinessSession.quotaId || laneSession.authorityDigestB64u !== readinessSession.authorityDigestB64u || laneSession.authorityRevocationEpoch !== readinessSession.authorityRevocationEpoch || laneAuthorization.operationCredential.walletSessionId !== readinessAuthorization.operationCredential.walletSessionId || laneAuthorization.operationCredential.token !== readinessAuthorization.operationCredential.token) throw new Error("[SigningSession] planner ECDSA readiness authority does not match its lane");
-	}
-	const policyBlock = getPolicyBlock(input);
-	if (policyBlock) return {
-		kind: SigningSessionPlanKind.NotReady,
-		lane,
-		reason: policyBlock
-	};
-	const forceFreshAuth = input.forceFreshAuth || input.sensitiveOperationPolicy === "require_fresh_same_method" || lane.retention === "single_use";
-	if (readiness.status === "ready" && !forceFreshAuth) {
-		if (lane.curve === "ed25519" && readiness.curve === "ed25519") return {
-			kind: SigningSessionPlanKind.WarmSession,
-			lane,
-			keyRef: {
-				kind: SigningKeyRefIntentKind.Cached,
-				curve: "ed25519",
-				thresholdSessionId: readiness.thresholdSessionId
-			}
-		};
-		if (lane.curve !== "ecdsa" || readiness.curve !== "ecdsa") throw new Error("[SigningSession] planner lane and readiness curves do not match");
-		return {
-			kind: SigningSessionPlanKind.WarmSession,
-			lane,
-			keyRef: {
-				kind: SigningKeyRefIntentKind.Cached,
-				curve: "ecdsa",
-				materialActivation: readiness.materialActivation,
-				authorization: readiness.authorization
-			}
-		};
-	}
-	if (readiness.status === "auth_unavailable" || readiness.status === "status_unavailable" || readiness.status === "status_unknown") return {
-		kind: SigningSessionPlanKind.NotReady,
-		lane,
-		reason: readiness.status
-	};
-	if (signingLaneAuthMethod(lane.auth) === "email_otp") return {
-		kind: SigningSessionPlanKind.EmailOtpReauth,
-		lane,
-		challenge: {
-			chainFamily: lane.chainFamily,
-			lane
-		}
-	};
-	if (lane.curve === "ed25519" && readiness.curve === "ed25519") return {
-		kind: SigningSessionPlanKind.PasskeyReauth,
-		lane,
-		reconnect: {
-			lane,
-			curve: "ed25519",
-			thresholdSessionId: readiness.thresholdSessionId
-		}
-	};
-	if (lane.curve !== "ecdsa" || readiness.curve !== "ecdsa") throw new Error("[SigningSession] planner lane and readiness curves do not match");
-	return {
-		kind: SigningSessionPlanKind.PasskeyReauth,
-		lane,
-		reconnect: {
-			lane,
-			curve: "ecdsa",
-			materialActivation: readiness.materialActivation,
-			authorization: readiness.authorization
-		}
-	};
-}
-function createSigningPlannerDecisionTraceEvent(input, plan) {
-	return {
-		event: "signing_planner_decision",
-		readinessStatus: input.readiness.status,
-		forceFreshAuth: Boolean(input.forceFreshAuth),
-		...input.sensitiveOperationPolicy ? { sensitiveOperationPolicy: input.sensitiveOperationPolicy } : {},
-		plan: summarizeSigningSessionPlan(plan),
-		lane: summarizeSigningLane(input.lane),
-		...plan.kind === SigningSessionPlanKind.NotReady ? { reason: plan.reason } : {}
-	};
-}
-function getPolicyBlock(input) {
-	if (signingLaneAuthMethod(input.lane.auth) !== "email_otp") return null;
-	if (input.sensitiveOperationPolicy === "deny_email_otp" || input.sensitiveOperationPolicy === "require_passkey") return "policy_blocked";
-	return null;
-}
-//#endregion
-//#region src/core/signingEngine/flows/signNear/signDelegate.ts
-function emitNearSigningEvent$1(onEvent, accountId, event) {
-	try {
-		onEvent?.(createSigningFlowEvent({
-			...event,
-			flowId: `signing:near:${String(accountId)}:${event.phase}`,
-			accountId: String(accountId)
-		}));
-	} catch {}
-}
-function nearPreparedStepUpEventAuthMethod(preparedStepUp) {
-	switch (preparedStepUp.kind) {
-		case "warm_session": return "warm_session";
-		case "passkey": return "passkey";
-		case "email_otp": return "email_otp";
-		default: return assertNeverNearPreparedStepUp(preparedStepUp);
-	}
-}
-function assertNeverNearPreparedStepUp(value) {
-	throw new Error(`[SigningEngine][near] unsupported prepared step-up: ${String(value)}`);
-}
-function requireNearDelegateOperationStepUpPreparation(value) {
-	if (!value) throw new Error("[SigningEngine][near] delegate operation step-up preparation is missing");
+//#region src/core/signingEngine/flows/signNear/shared/signatureOnlySigning.ts
+const REQUIRED_SIGNATURE_USES = 1;
+function requireOperationStepUpPreparationRef(label, value) {
+	if (!value) throw new Error(`[SigningEngine][near] ${label} operation step-up preparation is missing`);
 	return value;
 }
-function requirePreparedNearDelegateOperationStepUp(value) {
-	if (!value || value.kind !== "near_signature_only") throw new Error("[SigningEngine][near] delegate operation step-up preparation kind changed");
+function requirePreparedSignatureOnlyStepUp(label, value) {
+	if (!value || value.kind !== "near_signature_only") throw new Error(`[SigningEngine][near] ${label} operation step-up preparation kind changed`);
 	return value;
 }
-function requireNearDelegateOperationStepUpMaterial(value) {
-	if (!value) throw new Error("[SigningEngine][near] delegate operation step-up material is missing");
+function requireOperationStepUpMaterial(label, value) {
+	if (!value) throw new Error(`[SigningEngine][near] ${label} operation step-up material is missing`);
 	return value;
 }
-function requireNearDelegateSigningDigest(value) {
-	if (!value) throw new Error("[SigningEngine][near] delegate operation signing digest is missing");
+function requireSigningDigest(label, value) {
+	if (!value) throw new Error(`[SigningEngine][near] ${label} operation signing digest is missing`);
 	return value;
 }
-function requireAuthorizedNearDelegateWalletSessionState(value) {
+function requireAuthorizedWalletSessionState(value) {
 	if (!value) throw new Error("[SigningEngine][near] reusable Wallet Session authorization is unavailable");
 	return value;
 }
-async function resolveNearDelegateOperationStepUpCapability(args) {
+async function resolveSignatureOnlyOperationStepUpCapability(args) {
 	if (args.authorization.kind === "passkey") {
-		if (args.material.kind !== "passkey_live" && args.material.kind !== "passkey_sealed") throw new Error("[SigningEngine][near] passkey delegate material changed factor");
+		if (args.material.kind !== "passkey_live" && args.material.kind !== "passkey_sealed") throw new Error(`[SigningEngine][near] passkey ${args.label} material changed factor`);
 		return await resolveNearOperationStepUpMaterial({
 			kind: "passkey",
 			material: args.material,
@@ -3871,8 +3921,8 @@ async function resolveNearDelegateOperationStepUpCapability(args) {
 			credential: args.authorization.credential
 		});
 	}
-	if (args.material.kind !== "email_otp_live" && args.material.kind !== "email_otp_sealed") throw new Error("[SigningEngine][near] Email OTP delegate material changed factor");
-	if (!args.emailOtpProof) throw new Error("[SigningEngine][near] Email OTP delegate proof is missing");
+	if (args.material.kind !== "email_otp_live" && args.material.kind !== "email_otp_sealed") throw new Error(`[SigningEngine][near] Email OTP ${args.label} material changed factor`);
+	if (!args.emailOtpProof) throw new Error(`[SigningEngine][near] Email OTP ${args.label} proof is missing`);
 	if (args.material.kind === "email_otp_live") return await resolveNearOperationStepUpMaterial({
 		kind: "email_otp_live",
 		material: args.material,
@@ -3887,63 +3937,56 @@ async function resolveNearDelegateOperationStepUpCapability(args) {
 		proof: args.emailOtpProof
 	});
 }
-async function runNearDelegateActionSigning({ ctx, commandSubject, nearAccount, delegate, rpcCall, onEvent, confirmationConfigOverride, title, body, operationId, signerSlot, signingSessionCoordinator, forceFreshAuth, passkeyEd25519OperationStepUp, emailOtpEd25519StepUp, yaoSigningPreparation, yaoMaterialExecutor, selection }) {
-	const selectionAuth = selection.kind === "authorized" ? selection.selectedLane.auth : selection.candidate.auth;
-	const selectedSignerSlot = selection.kind === "authorized" ? selection.selectedLane.identity.signer.signerSlot : selection.candidate.signerSlot;
-	const nearAccountId = toAccountId(nearAccount.accountId);
-	const relayerUrl = ctx.relayerUrl;
-	const resolvedRpcCall = {
-		nearRpcUrl: rpcCall.nearRpcUrl || resolvePrimaryNearRpcUrl(PASSKEY_MANAGER_DEFAULT_CONFIGS.network.chains),
-		nearAccountId
-	};
-	const warnings = [];
-	const touchConfirm = ctx.touchConfirm;
-	if (!touchConfirm) throw new Error("UiConfirm bridge not available for delegate signing");
-	const requiredSignatureUses = 1;
-	let signingAuthPlan;
-	let signingSessionPlan;
-	if (selection.kind === "authorized") {
-		const selectedLane = selection.selectedLane;
-		const signingSessionAuthContext = resolveNearSigningSessionAuthContext({
-			requiredSignatureUses,
-			commandSubject,
-			forceFreshAuth,
-			selectedLane,
-			preparation: yaoSigningPreparation
+/**
+* Plans the signing session for the selected lane. A lane still awaiting authorization signs
+* once, through an operation step-up on its deferred material.
+*/
+function resolveNearSignatureOnlySigningPlans(args) {
+	if (args.selection.kind === "authorized") {
+		const context = resolveNearSigningSessionAuthContext({
+			requiredSignatureUses: REQUIRED_SIGNATURE_USES,
+			commandSubject: args.commandSubject,
+			forceFreshAuth: args.forceFreshAuth,
+			selectedLane: args.selection.selectedLane,
+			preparation: args.preparation
 		});
 		const resolvedSigningSession = {
 			signingSessionPlan: planSigningSession({
-				lane: signingSessionAuthContext.coordinatorInput.lane,
-				readiness: signingSessionAuthContext.coordinatorInput.readiness,
-				forceFreshAuth: signingSessionAuthContext.coordinatorInput.forceFreshAuth
+				lane: context.coordinatorInput.lane,
+				readiness: context.coordinatorInput.readiness,
+				forceFreshAuth: context.coordinatorInput.forceFreshAuth
 			}),
-			readiness: signingSessionAuthContext.coordinatorInput.readiness,
-			expiresAtMs: signingSessionAuthContext.coordinatorInput.expiresAtMs || 0,
-			remainingUses: signingSessionAuthContext.coordinatorInput.remainingUses || 0
+			readiness: context.coordinatorInput.readiness,
+			expiresAtMs: context.coordinatorInput.expiresAtMs || 0,
+			remainingUses: context.coordinatorInput.remainingUses || 0
 		};
-		signingSessionPlan = resolvedSigningSession.signingSessionPlan;
-		signingAuthPlan = buildNearSigningSessionAuthPlan({
-			context: signingSessionAuthContext,
-			resolvedSigningSession
-		}).signingAuthPlan;
-	} else {
-		signingAuthPlan = signingAuthPlanForNearMaterialRequirement(selectionAuth);
-		const candidate = selection.candidate;
-		const deferredIdentity = {
-			kind: "deferred_ed25519_material_identity",
-			signer: nearEd25519SignerBindingFromBoundaryFields({
-				walletId: candidate.walletId,
-				nearAccountId: candidate.nearAccountId,
-				nearEd25519SigningKeyId: candidate.nearEd25519SigningKeyId,
-				signerSlot: candidate.signerSlot
-			}),
-			materialActivation: candidate.materialActivation,
-			thresholdSessionId: SigningSessionIds.thresholdEd25519Session(candidate.thresholdSessionId)
+		return {
+			signingAuthPlan: buildNearSigningSessionAuthPlan({
+				context,
+				resolvedSigningSession
+			}).signingAuthPlan,
+			signingSessionPlan: resolvedSigningSession.signingSessionPlan
 		};
-		signingSessionPlan = {
-			kind: SigningSessionPlanKind.OperationStepUp,
-			lane: {
-				identity: deferredIdentity,
+	}
+	const candidate = args.selection.candidate;
+	const signingAuthPlan = signingAuthPlanForNearMaterialRequirement(candidate.auth);
+	const deferredIdentity = {
+		kind: "deferred_ed25519_material_identity",
+		signer: nearEd25519SignerBindingFromBoundaryFields({
+			walletId: candidate.walletId,
+			nearAccountId: candidate.nearAccountId,
+			nearEd25519SigningKeyId: candidate.nearEd25519SigningKeyId,
+			signerSlot: candidate.signerSlot
+		}),
+		materialActivation: candidate.materialActivation,
+		thresholdSessionId: SigningSessionIds.thresholdEd25519Session(candidate.thresholdSessionId)
+	};
+	return {
+		signingAuthPlan,
+		signingSessionPlan: {
+			kind: SigningSessionPlanKind.OperationStepUp,
+			lane: {
+				identity: deferredIdentity,
 				auth: candidate.auth,
 				curve: "ed25519",
 				keyKind: "threshold_ed25519",
@@ -3954,8 +3997,263 @@ async function runNearDelegateActionSigning({ ctx, commandSubject, nearAccount,
 				materialActivation: deferredIdentity.materialActivation,
 				thresholdSessionId: deferredIdentity.thresholdSessionId
 			}
+		}
+	};
+}
+/**
+* Prepares the step-up. Unless a warm session covers the operation, this also prepares the
+* operation material and registers the builder the confirmation calls to prepare the
+* Router A/B request.
+*/
+async function prepareNearSignatureOnlyStepUp(operation, args) {
+	const preparedStepUp = await requireNearStepUpAuth({
+		signingAuthPlan: args.signingAuthPlan,
+		signingLaneAuth: operation.auth,
+		requiredSignatureUses: REQUIRED_SIGNATURE_USES,
+		operationFingerprintDigest: parseSigningOperationFingerprintDigest(operation.signingOperation.operationFingerprint),
+		passkeyEd25519OperationStepUp: args.passkeyEd25519OperationStepUp,
+		emailOtpEd25519StepUp: args.emailOtpEd25519StepUp
+	});
+	if (preparedStepUp.kind === "warm_session") return {
+		preparedStepUp,
+		operationStepUp: null
+	};
+	const material = await prepareNearOperationStepUpMaterial({
+		method: preparedStepUp.kind,
+		preparation: operation.preparation,
+		executor: operation.executor
+	});
+	const materialFacts = nearOperationStepUpMaterialFacts(material);
+	const signingDigestB64u = await operation.computeSigningDigestB64u();
+	registerNearOperationStepUpBuilder({
+		requestId: String(operation.signingOperation.operationId),
+		build: async (preparation) => {
+			if (preparation.kind !== "near_signature_only") throw new Error(`[SigningEngine][near] ${operation.label} operation step-up preparation kind changed`);
+			return await prepareRouterAbEd25519SignatureOnlyOperationStepUp({
+				ctx: operation.ctx,
+				thresholdSessionId: materialFacts.thresholdSessionId,
+				materialFacts,
+				thresholdKeyMaterial: operation.thresholdKeyMaterial,
+				walletId: operation.walletId,
+				nearAccountId: operation.nearAccountId,
+				materialActivation: material.materialActivation,
+				operationId: operation.signingOperation.operationId,
+				operationFingerprint: operation.signingOperation.operationFingerprint,
+				displayDigest: preparation.displayDigest,
+				signingDigestB64u,
+				intent: operation.intent
+			});
+		}
+	});
+	return {
+		preparedStepUp,
+		operationStepUp: {
+			material,
+			signingDigestB64u
+		}
+	};
+}
+/** Shows the confirmation, then drops the step-up builder whether or not it was used. */
+async function confirmNearSignatureOnlyOperation(operation, args) {
+	const requestId = String(operation.signingOperation.operationId);
+	try {
+		return await runSigningConfirmationCommand({
+			signingSessionPlan: operation.signingSessionPlan,
+			signingOperation: operation.signingOperation,
+			runtime: args.touchConfirm,
+			request: {
+				ctx: { touchConfirm: args.touchConfirm },
+				sessionId: requestId,
+				chain: "near",
+				...args.request,
+				...buildSigningConfirmationAuthParams({ signingAuthPlan: args.signingAuthPlan }),
+				walletId: String(operation.walletId),
+				nearAccountId: operation.nearAccountId,
+				nearPublicKeyStr: args.nearPublicKeyStr,
+				title: args.title,
+				body: args.body,
+				confirmationConfigOverride: confirmationConfigForSigningAuthPlan({
+					signingAuthPlan: args.signingAuthPlan,
+					override: args.confirmationConfigOverride
+				}),
+				onProgress: emitNearSigningConfirmationProgress.bind(void 0, {
+					onEvent: args.onEvent,
+					nearAccountId: operation.nearAccountId,
+					signingAuthPlan: args.signingAuthPlan
+				})
+			}
+		});
+	} finally {
+		clearNearOperationStepUpBuilder(requestId);
+	}
+}
+/** Turns the confirmation into the authorization that the signing step presents. */
+function authorizeNearSignatureOnlyOperation(operation, stepUp, confirmation) {
+	const stepUpAuthorization = buildNearEd25519StepUpAuthorization({
+		prepared: stepUp.preparedStepUp,
+		confirmation
+	});
+	if (stepUpAuthorization.kind === "warm_session") return {
+		kind: "warm_session",
+		displayDigest: confirmation.intentDigest,
+		stepUpAuthorization
+	};
+	const proof = buildNearEd25519OperationStepUpProof({
+		authorization: stepUpAuthorization,
+		preparation: operation.preparation,
+		auth: operation.auth,
+		walletId: operation.walletId
+	});
+	const prepared = requirePreparedSignatureOnlyStepUp(operation.label, consumePreparedNearOperationStepUp({
+		requestId: String(operation.signingOperation.operationId),
+		ref: requireOperationStepUpPreparationRef(operation.label, confirmation.operationStepUpPreparation)
+	}));
+	return {
+		kind: "operation_step_up",
+		displayDigest: confirmation.intentDigest,
+		stepUpAuthorization,
+		proof,
+		prepared,
+		...requireOperationStepUpMaterial(operation.label, stepUp.operationStepUp)
+	};
+}
+async function resolveNearSignatureOnlySigningMaterial(operation, authorization) {
+	if (authorization.kind === "warm_session") {
+		const resolved = await resolveConfirmedNearEd25519YaoCapability({
+			authorization: authorization.stepUpAuthorization,
+			preparation: operation.preparation,
+			executor: operation.executor
+		});
+		return {
+			kind: "warm_session",
+			thresholdSessionId: resolved.thresholdSessionId,
+			displayDigest: authorization.displayDigest,
+			resolved
 		};
 	}
+	return {
+		kind: "operation_step_up",
+		thresholdSessionId: nearOperationStepUpMaterialFacts(authorization.material).thresholdSessionId,
+		displayDigest: authorization.displayDigest,
+		resolved: await resolveSignatureOnlyOperationStepUpCapability({
+			label: operation.label,
+			material: authorization.material,
+			prepared: authorization.prepared,
+			displayDigest: authorization.displayDigest,
+			authorization: authorization.stepUpAuthorization,
+			emailOtpProof: authorization.proof.kind === "email_otp" ? authorization.proof : null
+		}),
+		proof: authorization.proof,
+		prepared: authorization.prepared,
+		signingDigestB64u: authorization.signingDigestB64u
+	};
+}
+/** Signs through Router A/B with the reusable Wallet Session or the operation step-up. */
+async function signNearSignatureOnlyOperation(operation, material, signingSessionCoordinator) {
+	const signingDigestB64u = material.kind === "warm_session" ? await operation.computeSigningDigestB64u() : requireSigningDigest(operation.label, material.signingDigestB64u);
+	const result = material.kind === "warm_session" ? await tryFinalizeRouterAbEd25519SignatureOnlyNormalSigning({
+		ctx: operation.ctx,
+		thresholdSessionId: material.thresholdSessionId,
+		activeClient: material.resolved.material.activeClient,
+		walletSessionState: requireAuthorizedWalletSessionState(await signingSessionCoordinator.resolveActiveAuthorizedRouterAbEd25519WalletSessionState({
+			state: material.resolved.walletSessionState,
+			nowMs: Date.now()
+		})),
+		walletId: operation.walletId,
+		thresholdKeyMaterial: operation.thresholdKeyMaterial,
+		nearAccountId: operation.nearAccountId,
+		operationId: operation.signingOperation.operationId,
+		operationFingerprint: operation.signingOperation.operationFingerprint,
+		displayDigest: material.displayDigest,
+		signingDigestB64u,
+		intent: operation.intent,
+		authorization: { kind: "reusable_wallet_session" }
+	}) : await tryFinalizeRouterAbEd25519SignatureOnlyNormalSigning({
+		ctx: operation.ctx,
+		thresholdSessionId: material.thresholdSessionId,
+		activeClient: material.resolved.material.activeClient,
+		materialFacts: material.resolved.material.facts,
+		walletId: operation.walletId,
+		thresholdKeyMaterial: operation.thresholdKeyMaterial,
+		nearAccountId: operation.nearAccountId,
+		operationId: operation.signingOperation.operationId,
+		operationFingerprint: operation.signingOperation.operationFingerprint,
+		displayDigest: material.displayDigest,
+		signingDigestB64u,
+		intent: operation.intent,
+		authorization: {
+			kind: "operation_step_up",
+			prepared: material.prepared,
+			proof: material.proof,
+			issuedAuthorization: material.resolved.issuedAuthorization
+		}
+	});
+	if (!result) throw new Error(`[SigningEngine][near] Router A/B Ed25519 ${operation.label} signing is unavailable`);
+	if (material.kind === "operation_step_up" && result.authorization === "operation_step_up") requireIssuedNearEd25519OperationStepUpAuthorization({
+		prepared: material.prepared,
+		issuedAuthorization: result.issuedAuthorization
+	});
+	return {
+		signingDigestB64u,
+		signatureB64u: result.signatureB64u,
+		signerPublicKey: result.signerPublicKey
+	};
+}
+/** Runs the Sign command, rethrowing a thrown non-Error value as an Error. */
+async function runNearSignatureOnlySignCommand(operation, execute) {
+	return await runSigningOperationCommand({
+		signingSessionPlan: operation.signingSessionPlan,
+		signingOperation: operation.signingOperation,
+		commandKind: SigningOperationCommandKind.Sign,
+		execute: async () => {
+			try {
+				return await execute();
+			} catch (e) {
+				throw e instanceof Error ? e : new Error(String(e));
+			}
+		}
+	});
+}
+//#endregion
+//#region src/core/signingEngine/flows/signNear/signDelegate.ts
+function emitNearSigningEvent$1(onEvent, accountId, event) {
+	try {
+		onEvent?.(createSigningFlowEvent({
+			...event,
+			flowId: `signing:near:${String(accountId)}:${event.phase}`,
+			accountId: String(accountId)
+		}));
+	} catch {}
+}
+function nearPreparedStepUpEventAuthMethod(preparedStepUp) {
+	switch (preparedStepUp.kind) {
+		case "warm_session": return "warm_session";
+		case "passkey": return "passkey";
+		case "email_otp": return "email_otp";
+		default: return assertNeverNearPreparedStepUp(preparedStepUp);
+	}
+}
+function assertNeverNearPreparedStepUp(value) {
+	throw new Error(`[SigningEngine][near] unsupported prepared step-up: ${String(value)}`);
+}
+async function runNearDelegateActionSigning({ ctx, commandSubject, nearAccount, delegate, rpcCall, onEvent, confirmationConfigOverride, title, body, operationId, signerSlot, signingSessionCoordinator, forceFreshAuth, passkeyEd25519OperationStepUp, emailOtpEd25519StepUp, yaoSigningPreparation, yaoMaterialExecutor, selection }) {
+	const selectionAuth = selection.kind === "authorized" ? selection.selectedLane.auth : selection.candidate.auth;
+	const selectedSignerSlot = selection.kind === "authorized" ? selection.selectedLane.identity.signer.signerSlot : selection.candidate.signerSlot;
+	const nearAccountId = toAccountId(nearAccount.accountId);
+	const relayerUrl = ctx.relayerUrl;
+	const resolvedRpcCall = {
+		nearRpcUrl: rpcCall.nearRpcUrl || resolvePrimaryNearRpcUrl(PASSKEY_MANAGER_DEFAULT_CONFIGS.network.chains),
+		nearAccountId
+	};
+	const warnings = [];
+	const touchConfirm = ctx.touchConfirm;
+	if (!touchConfirm) throw new Error("UiConfirm bridge not available for delegate signing");
+	const { signingAuthPlan, signingSessionPlan } = resolveNearSignatureOnlySigningPlans({
+		selection,
+		commandSubject,
+		forceFreshAuth,
+		preparation: yaoSigningPreparation
+	});
 	emitNearSigningEvent$1(onEvent, nearAccountId, {
 		phase: SigningEventPhase.STEP_02_REQUEST_PREPARED,
 		status: "running",
@@ -4000,61 +4298,32 @@ async function runNearDelegateActionSigning({ ctx, commandSubject, nearAccount,
 		})),
 		intent: SigningOperationIntent.TransactionSign
 	};
-	const runSharedNearDelegateCommand = async (args) => await runSigningOperationCommand({
+	const operation = {
+		label: "delegate",
+		ctx,
+		walletId: commandSubject.walletSession.walletId,
+		nearAccountId,
+		auth: selectionAuth,
 		signingSessionPlan,
 		signingOperation,
-		commandKind: args.commandKind,
-		execute: args.execute
-	});
-	const preparedStepUp = await requireNearStepUpAuth({
+		thresholdKeyMaterial: signingContext.threshold.thresholdKeyMaterial,
+		preparation: yaoSigningPreparation,
+		executor: yaoMaterialExecutor,
+		intent: {
+			kind: "near_delegate_action_v1",
+			delegate: delegateIntent
+		},
+		computeSigningDigestB64u: async () => (await computeThresholdEd25519DelegateSigningDigestWasm({
+			delegate: delegateSigningPayloads.workerDelegate,
+			workerCtx: ctx
+		})).signingDigestB64u
+	};
+	const stepUp = await prepareNearSignatureOnlyStepUp(operation, {
 		signingAuthPlan,
-		signingLaneAuth: selectionAuth,
-		requiredSignatureUses,
-		operationFingerprintDigest: parseSigningOperationFingerprintDigest(signingOperation.operationFingerprint),
 		passkeyEd25519OperationStepUp,
 		emailOtpEd25519StepUp
 	});
-	const signatureOnlyIntent = {
-		kind: "near_delegate_action_v1",
-		delegate: delegateIntent
-	};
-	let operationStepUpMaterial = null;
-	let operationStepUpSigningDigestB64u = null;
-	if (preparedStepUp.kind !== "warm_session") {
-		operationStepUpMaterial = await prepareNearOperationStepUpMaterial({
-			method: preparedStepUp.kind,
-			preparation: yaoSigningPreparation,
-			executor: yaoMaterialExecutor
-		});
-		const material = operationStepUpMaterial;
-		const materialFacts = nearOperationStepUpMaterialFacts(material);
-		const signingDigest = await computeThresholdEd25519DelegateSigningDigestWasm({
-			delegate: delegateSigningPayloads.workerDelegate,
-			workerCtx: ctx
-		});
-		operationStepUpSigningDigestB64u = signingDigest.signingDigestB64u;
-		registerNearOperationStepUpBuilder({
-			requestId: String(operationId),
-			build: async (preparation) => {
-				if (preparation.kind !== "near_signature_only") throw new Error("[SigningEngine][near] delegate operation step-up preparation kind changed");
-				return await prepareRouterAbEd25519SignatureOnlyOperationStepUp({
-					ctx,
-					thresholdSessionId: materialFacts.thresholdSessionId,
-					materialFacts,
-					thresholdKeyMaterial: signingContext.threshold.thresholdKeyMaterial,
-					walletId: commandSubject.walletSession.walletId,
-					nearAccountId,
-					materialActivation: material.materialActivation,
-					operationId: signingOperation.operationId,
-					operationFingerprint: signingOperation.operationFingerprint,
-					displayDigest: preparation.displayDigest,
-					signingDigestB64u: signingDigest.signingDigestB64u,
-					intent: signatureOnlyIntent
-				});
-			}
-		});
-	}
-	const confirmationAuthPayload = preparedStepUp.confirmationAuthPayload;
+	const confirmationAuthPayload = stepUp.preparedStepUp.confirmationAuthPayload;
 	if (isWarmSessionSigningAuthPlan(confirmationAuthPayload.signingAuthPlan)) emitNearSigningEvent$1(onEvent, nearAccountId, {
 		phase: SigningEventPhase.STEP_06_AUTH_WARM_SESSION_CLAIMED,
 		status: "succeeded",
@@ -4077,39 +4346,20 @@ async function runNearDelegateActionSigning({ ctx, commandSubject, nearAccount,
 			overlay: "show"
 		}
 	});
-	let confirmation;
-	try {
-		confirmation = await runSigningConfirmationCommand({
-			signingSessionPlan,
-			signingOperation,
-			runtime: touchConfirm,
-			request: {
-				ctx: { touchConfirm },
-				sessionId: String(operationId),
-				chain: "near",
-				kind: "delegate",
-				...buildSigningConfirmationAuthParams({ signingAuthPlan: confirmationAuthPayload.signingAuthPlan }),
-				walletId: String(commandSubject.walletSession.walletId),
-				nearAccountId,
-				delegate: delegateSigningPayloads.confirmationDelegate,
-				rpcCall: resolvedRpcCall,
-				nearPublicKeyStr: signingContext.signingNearPublicKeyStr,
-				confirmationConfigOverride: confirmationConfigForSigningAuthPlan({
-					signingAuthPlan: confirmationAuthPayload.signingAuthPlan,
-					override: confirmationConfigOverride
-				}),
-				onProgress: emitNearSigningConfirmationProgress.bind(void 0, {
-					onEvent,
-					nearAccountId,
-					signingAuthPlan: confirmationAuthPayload.signingAuthPlan
-				}),
-				title,
-				body
-			}
-		});
-	} finally {
-		clearNearOperationStepUpBuilder(String(operationId));
-	}
+	const confirmation = await confirmNearSignatureOnlyOperation(operation, {
+		touchConfirm,
+		signingAuthPlan: confirmationAuthPayload.signingAuthPlan,
+		nearPublicKeyStr: signingContext.signingNearPublicKeyStr,
+		onEvent,
+		title,
+		body,
+		confirmationConfigOverride,
+		request: {
+			kind: "delegate",
+			delegate: delegateSigningPayloads.confirmationDelegate,
+			rpcCall: resolvedRpcCall
+		}
+	});
 	emitNearSigningEvent$1(onEvent, nearAccountId, {
 		phase: SigningEventPhase.STEP_05_CONFIRMATION_APPROVED,
 		status: "succeeded",
@@ -4118,21 +4368,10 @@ async function runNearDelegateActionSigning({ ctx, commandSubject, nearAccount,
 			overlay: "hide"
 		}
 	});
-	const stepUpAuthorization = buildNearEd25519StepUpAuthorization({
-		prepared: preparedStepUp,
-		confirmation
-	});
-	const operationStepUpProof = stepUpAuthorization.kind === "warm_session" ? null : buildNearEd25519OperationStepUpProof({
-		authorization: stepUpAuthorization,
-		preparation: yaoSigningPreparation,
-		auth: selectionAuth,
-		walletId: commandSubject.walletSession.walletId
-	});
-	const preparedOperationStepUp = stepUpAuthorization.kind === "warm_session" ? null : requirePreparedNearDelegateOperationStepUp(consumePreparedNearOperationStepUp({
-		requestId: String(operationId),
-		ref: requireNearDelegateOperationStepUpPreparation(confirmation.operationStepUpPreparation)
-	}));
-	const { canonicalThresholdSessionId, delegatePayload, resolvedMaterial } = await runSharedNearDelegateCommand({
+	const authorization = authorizeNearSignatureOnlyOperation(operation, stepUp, confirmation);
+	const signingMaterial = await runSigningOperationCommand({
+		signingSessionPlan,
+		signingOperation,
 		commandKind: SigningOperationCommandKind.PreparePayload,
 		execute: async () => {
 			emitNearSigningEvent$1(onEvent, nearAccountId, {
@@ -4144,24 +4383,7 @@ async function runNearDelegateActionSigning({ ctx, commandSubject, nearAccount,
 					overlay: "none"
 				}
 			});
-			const resolvedMaterial = stepUpAuthorization.kind === "warm_session" ? {
-				kind: "warm_session",
-				resolved: await resolveConfirmedNearEd25519YaoCapability({
-					authorization: stepUpAuthorization,
-					preparation: yaoSigningPreparation,
-					executor: yaoMaterialExecutor
-				})
-			} : {
-				kind: "operation_step_up",
-				thresholdSessionId: nearOperationStepUpMaterialFacts(requireNearDelegateOperationStepUpMaterial(operationStepUpMaterial)).thresholdSessionId,
-				resolved: await resolveNearDelegateOperationStepUpCapability({
-					material: requireNearDelegateOperationStepUpMaterial(operationStepUpMaterial),
-					prepared: requirePreparedNearDelegateOperationStepUp(preparedOperationStepUp),
-					displayDigest: confirmation.intentDigest,
-					authorization: stepUpAuthorization,
-					emailOtpProof: operationStepUpProof?.kind === "email_otp" ? operationStepUpProof : null
-				})
-			};
+			const material = await resolveNearSignatureOnlySigningMaterial(operation, authorization);
 			emitNearSigningEvent$1(onEvent, nearAccountId, {
 				phase: SigningEventPhase.STEP_07_AUTHENTICATION_COMPLETE,
 				status: "succeeded",
@@ -4169,10 +4391,8 @@ async function runNearDelegateActionSigning({ ctx, commandSubject, nearAccount,
 					kind: "none",
 					overlay: "none"
 				},
-				authMethod: nearPreparedStepUpEventAuthMethod(preparedStepUp)
+				authMethod: nearPreparedStepUpEventAuthMethod(stepUp.preparedStepUp)
 			});
-			const delegatePayload = delegateSigningPayloads.workerDelegate;
-			const canonicalThresholdSessionId = resolvedMaterial.kind === "warm_session" ? resolvedMaterial.resolved.thresholdSessionId : resolvedMaterial.thresholdSessionId;
 			emitNearSigningEvent$1(onEvent, nearAccountId, {
 				phase: SigningEventPhase.STEP_08_SIGNER_PREPARE_SUCCEEDED,
 				status: "succeeded",
@@ -4183,18 +4403,14 @@ async function runNearDelegateActionSigning({ ctx, commandSubject, nearAccount,
 				},
 				data: {
 					signer: "threshold-ed25519",
-					thresholdSessionId: canonicalThresholdSessionId,
+					thresholdSessionId: material.thresholdSessionId,
 					clientBaseSource: "yao_active_client"
 				}
 			});
-			return {
-				canonicalThresholdSessionId,
-				delegatePayload,
-				resolvedMaterial
-			};
+			return material;
 		}
 	});
-	const executeDelegateRequest = async () => {
+	const okResponse = await runNearSignatureOnlySignCommand(operation, async () => {
 		emitNearSigningEvent$1(onEvent, nearAccountId, {
 			phase: SigningEventPhase.STEP_10_COMMIT_STARTED,
 			status: "running",
@@ -4203,80 +4419,23 @@ async function runNearDelegateActionSigning({ ctx, commandSubject, nearAccount,
 				overlay: "none"
 			}
 		});
-		const signingDigestB64u = stepUpAuthorization.kind === "warm_session" ? (await computeThresholdEd25519DelegateSigningDigestWasm({
-			delegate: delegatePayload,
-			workerCtx: ctx
-		})).signingDigestB64u : requireNearDelegateSigningDigest(operationStepUpSigningDigestB64u);
-		const routerAbNormalSigningResult = resolvedMaterial.kind === "warm_session" ? await tryFinalizeRouterAbEd25519SignatureOnlyNormalSigning({
+		const signed = await signNearSignatureOnlyOperation(operation, signingMaterial, signingSessionCoordinator);
+		const delegateResult = await finalizeThresholdEd25519DelegateSignatureResult({
 			ctx,
-			thresholdSessionId: canonicalThresholdSessionId,
-			activeClient: resolvedMaterial.resolved.material.activeClient,
-			walletSessionState: requireAuthorizedNearDelegateWalletSessionState(await signingSessionCoordinator.resolveActiveAuthorizedRouterAbEd25519WalletSessionState({
-				state: resolvedMaterial.resolved.walletSessionState,
-				nowMs: Date.now()
-			})),
-			walletId: commandSubject.walletSession.walletId,
-			thresholdKeyMaterial: signingContext.threshold.thresholdKeyMaterial,
-			nearAccountId,
-			operationId: signingOperation.operationId,
-			operationFingerprint: signingOperation.operationFingerprint,
-			displayDigest: confirmation.intentDigest,
-			signingDigestB64u,
-			intent: signatureOnlyIntent,
-			authorization: { kind: "reusable_wallet_session" }
-		}) : await tryFinalizeRouterAbEd25519SignatureOnlyNormalSigning({
-			ctx,
-			thresholdSessionId: canonicalThresholdSessionId,
-			activeClient: resolvedMaterial.resolved.material.activeClient,
-			materialFacts: resolvedMaterial.resolved.material.facts,
-			walletId: commandSubject.walletSession.walletId,
-			thresholdKeyMaterial: signingContext.threshold.thresholdKeyMaterial,
-			nearAccountId,
-			operationId: signingOperation.operationId,
-			operationFingerprint: signingOperation.operationFingerprint,
-			displayDigest: confirmation.intentDigest,
-			signingDigestB64u,
-			intent: signatureOnlyIntent,
-			authorization: {
-				kind: "operation_step_up",
-				prepared: requirePreparedNearDelegateOperationStepUp(preparedOperationStepUp),
-				proof: requireNearEd25519OperationStepUpProof(operationStepUpProof),
-				issuedAuthorization: resolvedMaterial.resolved.issuedAuthorization
-			}
+			delegate: delegateSigningPayloads.workerDelegate,
+			signingDigestB64u: signed.signingDigestB64u,
+			signatureB64u: signed.signatureB64u
 		});
-		if (routerAbNormalSigningResult) {
-			if (resolvedMaterial.kind === "operation_step_up" && routerAbNormalSigningResult.authorization === "operation_step_up") requireIssuedNearEd25519OperationStepUpAuthorization({
-				prepared: requirePreparedNearDelegateOperationStepUp(preparedOperationStepUp),
-				issuedAuthorization: routerAbNormalSigningResult.issuedAuthorization
-			});
-			const delegateResult = await finalizeThresholdEd25519DelegateSignatureResult({
-				ctx,
-				delegate: delegatePayload,
-				signingDigestB64u,
-				signatureB64u: routerAbNormalSigningResult.signatureB64u
-			});
-			return {
-				type: WorkerResponseType.SignDelegateActionSuccess,
-				payload: {
-					success: true,
-					hash: delegateResult.hash,
-					signedDelegate: delegateResult.signedDelegate,
-					logs: ["Delegate action signed through Router A/B normal signing"],
-					error: void 0
-				}
-			};
-		}
-		throw new Error("[SigningEngine][near] Router A/B Ed25519 delegate signing is unavailable");
-	};
-	const okResponse = await runSharedNearDelegateCommand({
-		commandKind: SigningOperationCommandKind.Sign,
-		execute: async () => {
-			try {
-				return await executeDelegateRequest();
-			} catch (e) {
-				throw e instanceof Error ? e : new Error(String(e));
+		return {
+			type: WorkerResponseType.SignDelegateActionSuccess,
+			payload: {
+				success: true,
+				hash: delegateResult.hash,
+				signedDelegate: delegateResult.signedDelegate,
+				logs: ["Delegate action signed through Router A/B normal signing"],
+				error: void 0
 			}
-		}
+		};
 	});
 	emitNearSigningEvent$1(onEvent, nearAccountId, {
 		phase: SigningEventPhase.STEP_11_TRANSACTION_SIGNED,
@@ -4327,52 +4486,6 @@ function validateAndPrepareDelegateSigningContext(args) {
 }
 //#endregion
 //#region src/core/signingEngine/flows/signNear/signNep413.ts
-function requireNearNep413OperationStepUpPreparation(value) {
-	if (!value) throw new Error("[SigningEngine][near] NEP-413 operation step-up preparation is missing");
-	return value;
-}
-function requirePreparedNearNep413OperationStepUp(value) {
-	if (!value || value.kind !== "near_signature_only") throw new Error("[SigningEngine][near] NEP-413 operation step-up preparation kind changed");
-	return value;
-}
-function requireNearNep413OperationStepUpMaterial(value) {
-	if (!value) throw new Error("[SigningEngine][near] NEP-413 operation step-up material is missing");
-	return value;
-}
-function requireNearNep413SigningDigest(value) {
-	if (!value) throw new Error("[SigningEngine][near] NEP-413 operation signing digest is missing");
-	return value;
-}
-function requireAuthorizedNearNep413WalletSessionState(value) {
-	if (!value) throw new Error("[SigningEngine][near] reusable Wallet Session authorization is unavailable");
-	return value;
-}
-async function resolveNearNep413OperationStepUpCapability(args) {
-	if (args.authorization.kind === "passkey") {
-		if (args.material.kind !== "passkey_live" && args.material.kind !== "passkey_sealed") throw new Error("[SigningEngine][near] passkey NEP-413 material changed factor");
-		return await resolveNearOperationStepUpMaterial({
-			kind: "passkey",
-			material: args.material,
-			expectedActivation: args.prepared.materialActivation,
-			credential: args.authorization.credential
-		});
-	}
-	if (args.material.kind !== "email_otp_live" && args.material.kind !== "email_otp_sealed") throw new Error("[SigningEngine][near] Email OTP NEP-413 material changed factor");
-	if (!args.emailOtpProof) throw new Error("[SigningEngine][near] Email OTP NEP-413 proof is missing");
-	if (args.material.kind === "email_otp_live") return await resolveNearOperationStepUpMaterial({
-		kind: "email_otp_live",
-		material: args.material,
-		expectedActivation: args.prepared.materialActivation
-	});
-	return await resolveNearOperationStepUpMaterial({
-		kind: "email_otp_sealed",
-		material: args.material,
-		expectedActivation: args.prepared.materialActivation,
-		normalSigningRequest: args.prepared.prepare.request,
-		displayDigest: args.displayDigest,
-		proof: args.emailOtpProof
-	});
-}
 async function signNep413Message({ ctx, commandSubject, nearAccount, signingSessionCoordinator, payload, forceFreshAuth, passkeyEd25519OperationStepUp, emailOtpEd25519StepUp, yaoSigningPreparation, yaoMaterialExecutor, selection, onEvent }) {
 	const selectionAuth = selection.kind === "authorized" ? selection.selectedLane.auth : selection.candidate.auth;
 	const selectedSignerSlot = selection.kind === "authorized" ? selection.selectedLane.identity.signer.signerSlot : selection.candidate.signerSlot;
@@ -4381,62 +4494,12 @@ async function signNep413Message({ ctx, commandSubject, nearAccount, signingSess
 	const nearAccountId = nearAccount.accountId;
 	const touchConfirm = ctx.touchConfirm;
 	if (!touchConfirm) throw new Error("UiConfirm bridge not available for NEP-413 signing");
-	const requiredSignatureUses = 1;
-	let signingAuthPlan;
-	let signingSessionPlan;
-	if (selection.kind === "authorized") {
-		const signingSessionAuthContext = resolveNearSigningSessionAuthContext({
-			requiredSignatureUses,
-			commandSubject,
-			forceFreshAuth,
-			selectedLane: selection.selectedLane,
-			preparation: yaoSigningPreparation
-		});
-		const resolvedSigningSession = {
-			signingSessionPlan: planSigningSession({
-				lane: signingSessionAuthContext.coordinatorInput.lane,
-				readiness: signingSessionAuthContext.coordinatorInput.readiness,
-				forceFreshAuth: signingSessionAuthContext.coordinatorInput.forceFreshAuth
-			}),
-			readiness: signingSessionAuthContext.coordinatorInput.readiness,
-			expiresAtMs: signingSessionAuthContext.coordinatorInput.expiresAtMs || 0,
-			remainingUses: signingSessionAuthContext.coordinatorInput.remainingUses || 0
-		};
-		signingAuthPlan = buildNearSigningSessionAuthPlan({
-			context: signingSessionAuthContext,
-			resolvedSigningSession
-		}).signingAuthPlan;
-		signingSessionPlan = resolvedSigningSession.signingSessionPlan;
-	} else {
-		const candidate = selection.candidate;
-		signingAuthPlan = signingAuthPlanForNearMaterialRequirement(selectionAuth);
-		const deferredIdentity = {
-			kind: "deferred_ed25519_material_identity",
-			signer: nearEd25519SignerBindingFromBoundaryFields({
-				walletId: candidate.walletId,
-				nearAccountId: candidate.nearAccountId,
-				nearEd25519SigningKeyId: candidate.nearEd25519SigningKeyId,
-				signerSlot: candidate.signerSlot
-			}),
-			materialActivation: candidate.materialActivation,
-			thresholdSessionId: SigningSessionIds.thresholdEd25519Session(candidate.thresholdSessionId)
-		};
-		signingSessionPlan = {
-			kind: SigningSessionPlanKind.OperationStepUp,
-			lane: {
-				identity: deferredIdentity,
-				auth: candidate.auth,
-				curve: "ed25519",
-				keyKind: "threshold_ed25519",
-				chainFamily: "near",
-				sessionOrigin: "per_operation",
-				storageSource: "sealed_restore",
-				retention: "single_use",
-				materialActivation: deferredIdentity.materialActivation,
-				thresholdSessionId: deferredIdentity.thresholdSessionId
-			}
-		};
-	}
+	const { signingAuthPlan, signingSessionPlan } = resolveNearSignatureOnlySigningPlans({
+		selection,
+		commandSubject,
+		forceFreshAuth,
+		preparation: yaoSigningPreparation
+	});
 	const { thresholdKeyMaterial } = await resolveNearSigningMaterials({
 		materialExecutor: yaoMaterialExecutor,
 		nearAccount,
@@ -4463,208 +4526,68 @@ async function signNep413Message({ ctx, commandSubject, nearAccount, signingSess
 		})),
 		intent: SigningOperationIntent.TransactionSign
 	};
-	const runSharedNearNep413Command = async (args) => await runSigningOperationCommand({
+	const operation = {
+		label: "NEP-413",
+		ctx,
+		walletId: commandSubject.walletSession.walletId,
+		nearAccountId,
+		auth: selectionAuth,
 		signingSessionPlan,
 		signingOperation,
-		commandKind: args.commandKind,
-		execute: args.execute
-	});
-	const preparedStepUp = await requireNearStepUpAuth({
-		signingAuthPlan,
-		signingLaneAuth: selectionAuth,
-		requiredSignatureUses,
-		operationFingerprintDigest: parseSigningOperationFingerprintDigest(signingOperation.operationFingerprint),
-		passkeyEd25519OperationStepUp,
-		emailOtpEd25519StepUp
-	});
-	const signatureOnlyIntent = {
-		kind: "nep413_message_v1",
-		message: payload.message,
-		recipient: payload.recipient,
-		nonce: payload.nonce,
-		...payload.state ? { state: payload.state } : {}
-	};
-	let operationStepUpMaterial = null;
-	let operationStepUpSigningDigestB64u = null;
-	if (preparedStepUp.kind !== "warm_session") {
-		operationStepUpMaterial = await prepareNearOperationStepUpMaterial({
-			method: preparedStepUp.kind,
-			preparation: yaoSigningPreparation,
-			executor: yaoMaterialExecutor
-		});
-		const material = operationStepUpMaterial;
-		const materialFacts = nearOperationStepUpMaterialFacts(material);
-		const signingDigest = await computeThresholdEd25519Nep413SigningDigestWasm({
+		thresholdKeyMaterial: signingContext.threshold.thresholdKeyMaterial,
+		preparation: yaoSigningPreparation,
+		executor: yaoMaterialExecutor,
+		intent: {
+			kind: "nep413_message_v1",
 			message: payload.message,
 			recipient: payload.recipient,
 			nonce: payload.nonce,
-			...payload.state ? { state: payload.state } : {},
-			workerCtx: ctx
-		});
-		operationStepUpSigningDigestB64u = signingDigest.signingDigestB64u;
-		registerNearOperationStepUpBuilder({
-			requestId: String(operationId),
-			build: async (preparation) => {
-				if (preparation.kind !== "near_signature_only") throw new Error("[SigningEngine][near] NEP-413 operation step-up preparation kind changed");
-				return await prepareRouterAbEd25519SignatureOnlyOperationStepUp({
-					ctx,
-					thresholdSessionId: materialFacts.thresholdSessionId,
-					materialFacts,
-					thresholdKeyMaterial: signingContext.threshold.thresholdKeyMaterial,
-					walletId: commandSubject.walletSession.walletId,
-					nearAccountId,
-					materialActivation: material.materialActivation,
-					operationId: signingOperation.operationId,
-					operationFingerprint: signingOperation.operationFingerprint,
-					displayDigest: preparation.displayDigest,
-					signingDigestB64u: signingDigest.signingDigestB64u,
-					intent: signatureOnlyIntent
-				});
-			}
-		});
-	}
-	let confirmation;
-	try {
-		confirmation = await runSigningConfirmationCommand({
-			signingSessionPlan,
-			signingOperation,
-			runtime: touchConfirm,
-			request: {
-				ctx: { touchConfirm },
-				sessionId: String(operationId),
-				chain: "near",
-				kind: "nep413",
-				...buildSigningConfirmationAuthParams({ signingAuthPlan: preparedStepUp.confirmationAuthPayload.signingAuthPlan }),
-				walletId: String(commandSubject.walletSession.walletId),
-				nearAccountId,
-				nearPublicKeyStr: signingContext.nearPublicKey,
-				message: payload.message,
-				recipient: payload.recipient,
-				title: payload.title,
-				body: payload.body,
-				confirmationConfigOverride: confirmationConfigForSigningAuthPlan({
-					signingAuthPlan: preparedStepUp.confirmationAuthPayload.signingAuthPlan,
-					override: payload.confirmationConfigOverride
-				}),
-				onProgress: emitNearSigningConfirmationProgress.bind(void 0, {
-					onEvent,
-					nearAccountId,
-					signingAuthPlan: preparedStepUp.confirmationAuthPayload.signingAuthPlan
-				})
-			}
-		});
-	} finally {
-		clearNearOperationStepUpBuilder(String(operationId));
-	}
-	const stepUpAuthorization = buildNearEd25519StepUpAuthorization({
-		prepared: preparedStepUp,
-		confirmation
-	});
-	const operationStepUpProof = stepUpAuthorization.kind === "warm_session" ? null : buildNearEd25519OperationStepUpProof({
-		authorization: stepUpAuthorization,
-		preparation: yaoSigningPreparation,
-		auth: selectionAuth,
-		walletId: commandSubject.walletSession.walletId
-	});
-	const preparedOperationStepUp = stepUpAuthorization.kind === "warm_session" ? null : requirePreparedNearNep413OperationStepUp(consumePreparedNearOperationStepUp({
-		requestId: String(operationId),
-		ref: requireNearNep413OperationStepUpPreparation(confirmation.operationStepUpPreparation)
-	}));
-	const preparedMaterial = await runSharedNearNep413Command({
-		commandKind: SigningOperationCommandKind.PreparePayload,
-		execute: async () => {
-			return stepUpAuthorization.kind === "warm_session" ? {
-				kind: "warm_session",
-				resolved: await resolveConfirmedNearEd25519YaoCapability({
-					authorization: stepUpAuthorization,
-					preparation: yaoSigningPreparation,
-					executor: yaoMaterialExecutor
-				})
-			} : {
-				kind: "operation_step_up",
-				thresholdSessionId: nearOperationStepUpMaterialFacts(requireNearNep413OperationStepUpMaterial(operationStepUpMaterial)).thresholdSessionId,
-				resolved: await resolveNearNep413OperationStepUpCapability({
-					material: requireNearNep413OperationStepUpMaterial(operationStepUpMaterial),
-					prepared: requirePreparedNearNep413OperationStepUp(preparedOperationStepUp),
-					displayDigest: confirmation.intentDigest,
-					authorization: stepUpAuthorization,
-					emailOtpProof: operationStepUpProof?.kind === "email_otp" ? operationStepUpProof : null
-				})
-			};
-		}
-	});
-	const canonicalThresholdSessionId = preparedMaterial.kind === "warm_session" ? preparedMaterial.resolved.thresholdSessionId : preparedMaterial.thresholdSessionId;
-	const executeNep413Request = async () => {
-		const signingDigestB64u = stepUpAuthorization.kind === "warm_session" ? (await computeThresholdEd25519Nep413SigningDigestWasm({
+			...payload.state ? { state: payload.state } : {}
+		},
+		computeSigningDigestB64u: async () => (await computeThresholdEd25519Nep413SigningDigestWasm({
 			message: payload.message,
 			recipient: payload.recipient,
 			nonce: payload.nonce,
 			...payload.state ? { state: payload.state } : {},
 			workerCtx: ctx
-		})).signingDigestB64u : requireNearNep413SigningDigest(operationStepUpSigningDigestB64u);
-		const routerAbNormalSigningResult = preparedMaterial.kind === "warm_session" ? await tryFinalizeRouterAbEd25519SignatureOnlyNormalSigning({
-			ctx,
-			thresholdSessionId: canonicalThresholdSessionId,
-			activeClient: preparedMaterial.resolved.material.activeClient,
-			walletSessionState: requireAuthorizedNearNep413WalletSessionState(await signingSessionCoordinator.resolveActiveAuthorizedRouterAbEd25519WalletSessionState({
-				state: preparedMaterial.resolved.walletSessionState,
-				nowMs: Date.now()
-			})),
-			walletId: commandSubject.walletSession.walletId,
-			thresholdKeyMaterial: signingContext.threshold.thresholdKeyMaterial,
-			nearAccountId,
-			operationId: signingOperation.operationId,
-			operationFingerprint: signingOperation.operationFingerprint,
-			displayDigest: confirmation.intentDigest,
-			signingDigestB64u,
-			intent: signatureOnlyIntent,
-			authorization: { kind: "reusable_wallet_session" }
-		}) : await tryFinalizeRouterAbEd25519SignatureOnlyNormalSigning({
-			ctx,
-			thresholdSessionId: canonicalThresholdSessionId,
-			activeClient: preparedMaterial.resolved.material.activeClient,
-			materialFacts: preparedMaterial.resolved.material.facts,
-			walletId: commandSubject.walletSession.walletId,
-			thresholdKeyMaterial: signingContext.threshold.thresholdKeyMaterial,
-			nearAccountId,
-			operationId: signingOperation.operationId,
-			operationFingerprint: signingOperation.operationFingerprint,
-			displayDigest: confirmation.intentDigest,
-			signingDigestB64u,
-			intent: signatureOnlyIntent,
-			authorization: {
-				kind: "operation_step_up",
-				prepared: requirePreparedNearNep413OperationStepUp(preparedOperationStepUp),
-				proof: requireNearEd25519OperationStepUpProof(operationStepUpProof),
-				issuedAuthorization: preparedMaterial.resolved.issuedAuthorization
-			}
-		});
-		if (routerAbNormalSigningResult) {
-			if (preparedMaterial.kind === "operation_step_up" && routerAbNormalSigningResult.authorization === "operation_step_up") requireIssuedNearEd25519OperationStepUpAuthorization({
-				prepared: requirePreparedNearNep413OperationStepUp(preparedOperationStepUp),
-				issuedAuthorization: routerAbNormalSigningResult.issuedAuthorization
-			});
-			return {
-				type: WorkerResponseType.SignNep413MessageSuccess,
-				payload: {
-					accountId: nearAccountId,
-					publicKey: routerAbNormalSigningResult.signerPublicKey,
-					signature: base64Encode(base64UrlDecode(routerAbNormalSigningResult.signatureB64u)),
-					state: payload.state || void 0
-				}
-			};
-		}
-		throw new Error("[SigningEngine][near] Router A/B Ed25519 NEP-413 signing is unavailable");
+		})).signingDigestB64u
 	};
-	const okResponse = await runSharedNearNep413Command({
-		commandKind: SigningOperationCommandKind.Sign,
-		execute: async () => {
-			try {
-				return await executeNep413Request();
-			} catch (e) {
-				throw e instanceof Error ? e : new Error(String(e));
-			}
+	const stepUp = await prepareNearSignatureOnlyStepUp(operation, {
+		signingAuthPlan,
+		passkeyEd25519OperationStepUp,
+		emailOtpEd25519StepUp
+	});
+	const authorization = authorizeNearSignatureOnlyOperation(operation, stepUp, await confirmNearSignatureOnlyOperation(operation, {
+		touchConfirm,
+		signingAuthPlan: stepUp.preparedStepUp.confirmationAuthPayload.signingAuthPlan,
+		nearPublicKeyStr: signingContext.nearPublicKey,
+		onEvent,
+		title: payload.title,
+		body: payload.body,
+		confirmationConfigOverride: payload.confirmationConfigOverride,
+		request: {
+			kind: "nep413",
+			message: payload.message,
+			recipient: payload.recipient
 		}
+	}));
+	const signingMaterial = await runSigningOperationCommand({
+		signingSessionPlan,
+		signingOperation,
+		commandKind: SigningOperationCommandKind.PreparePayload,
+		execute: async () => await resolveNearSignatureOnlySigningMaterial(operation, authorization)
+	});
+	const okResponse = await runNearSignatureOnlySignCommand(operation, async () => {
+		const signed = await signNearSignatureOnlyOperation(operation, signingMaterial, signingSessionCoordinator);
+		return {
+			type: WorkerResponseType.SignNep413MessageSuccess,
+			payload: {
+				accountId: nearAccountId,
+				publicKey: signed.signerPublicKey,
+				signature: base64Encode(base64UrlDecode(signed.signatureB64u)),
+				state: payload.state || void 0
+			}
+		};
 	});
 	return {
 		success: true,
@@ -4741,50 +4664,14 @@ function validateNep413Request(payload) {
 }
 //#endregion
 //#region src/core/signingEngine/threshold/ed25519/commitQueue.ts
-function createThresholdEd25519CommitQueueOverflowError(nearAccountId, queueKey, maxQueueLength) {
-	const accountId = String(nearAccountId);
-	const err = /* @__PURE__ */ new Error(`[SigningEngine] threshold Ed25519 commit queue overflow for ${accountId} (queueKey=${queueKey}, max=${maxQueueLength})`);
-	err.code = "commit_queue_overflow";
-	return err;
-}
-function createThresholdEd25519CommitQueueTimeoutError(nearAccountId, queueKey, timeoutMs) {
-	const accountId = String(nearAccountId);
-	const err = /* @__PURE__ */ new Error(`[SigningEngine] threshold Ed25519 commit queue timeout for ${accountId} (queueKey=${queueKey}, waited>${timeoutMs}ms before start)`);
-	err.code = "commit_queue_timeout";
-	return err;
-}
-function createThresholdEd25519CommitQueueCancelledError(nearAccountId, queueKey, reason = "cancelled") {
-	const accountId = String(nearAccountId);
-	const message = reason === "queue_cleared" ? `[SigningEngine] threshold Ed25519 queued commit cancelled for ${accountId} (queueKey=${queueKey}, queue_cleared)` : `[SigningEngine] threshold Ed25519 queued commit cancelled for ${accountId} (queueKey=${queueKey})`;
-	const err = new Error(message);
-	err.code = "cancelled";
-	return err;
-}
-function resolveThresholdEd25519CommitQueueKey(args) {
-	return [
-		"material",
-		encodeURIComponent(String(args.materialActivation.materialOwner)),
-		encodeURIComponent(String(args.materialActivation.capability)),
-		encodeURIComponent(String(args.materialActivation.activationId))
-	].join(":");
-}
 async function withThresholdEd25519CommitQueue$1(args) {
-	const queueKey = String(args.queueKey || "").trim();
-	if (!queueKey) throw new Error("[SigningEngine] threshold Ed25519 commit queue requires non-empty queueKey");
-	const accountKey = String(args.nearAccountId);
 	return await withThresholdCommitQueue({
-		queueByKey: args.queueByKey,
-		queueKey,
-		enabled: args.enabled,
-		shouldAbort: args.shouldAbort,
-		maxQueueLength: args.maxQueueLength,
-		queueTimeoutMs: args.queueTimeoutMs,
-		task: args.task,
-		errors: {
-			makeOverflowError: (queueKey, maxQueueLength) => createThresholdEd25519CommitQueueOverflowError(accountKey, queueKey, maxQueueLength),
-			makeTimeoutError: (queueKey, timeoutMs) => createThresholdEd25519CommitQueueTimeoutError(accountKey, queueKey, timeoutMs),
-			makeCancelledError: (queueKey, reason) => createThresholdEd25519CommitQueueCancelledError(accountKey, queueKey, reason)
-		}
+		...args,
+		labels: {
+			queue: "threshold Ed25519 commit queue",
+			queuedOperation: "threshold Ed25519 queued commit"
+		},
+		owner: String(args.nearAccountId)
 	});
 }
 //#endregion
@@ -5216,7 +5103,7 @@ async function prepareNearAdHocSigningSession(args) {
 	};
 }
 async function withThresholdEd25519CommitQueue(args) {
-	const queueKey = resolveThresholdEd25519CommitQueueKey({ materialActivation: args.materialActivation });
+	const queueKey = resolveThresholdCommitQueueKey({ materialActivation: args.materialActivation });
 	return await args.deps.withThresholdEd25519CommitQueue({
 		queueKey,
 		nearAccountId: args.nearAccountId,
@@ -5529,35 +5416,24 @@ async function prepareNearEd25519TransactionSigningSession(args) {
 		transactionOperation
 	};
 }
-function buildNearTransactionPreparationDisplayModel(args) {
-	const signerAccount = String(args.commandSubject.nearAccount.accountId);
-	try {
-		return buildNearDisplayModel({
-			txSigningRequests: [args.transaction],
-			signerAccount,
-			title: args.title,
-			subtitle: args.body
-		});
-	} catch {
-		return {
-			chain: "near",
-			signerAccount,
-			...args.title ? { title: args.title } : {},
-			...args.body ? { subtitle: args.body } : {},
-			operations: []
-		};
-	}
-}
 async function signTransactionWithActions(deps, args) {
+	const modalStartedAt = performance.now();
 	await deps.touchConfirm.openTransactionPreparationModal({
 		chain: "near",
 		walletLabel: String(args.commandSubject.nearAccount.accountId),
 		txSigningRequests: [args.transaction],
-		model: buildNearTransactionPreparationDisplayModel(args),
+		model: buildNearPreparationDisplayModel({
+			txSigningRequests: [args.transaction],
+			signerAccount: String(args.commandSubject.nearAccount.accountId),
+			title: args.title,
+			subtitle: args.body
+		}),
 		confirmationConfigOverride: args.confirmationConfigOverride
 	});
 	try {
-		return await signTransactionWithActionsAttempt(deps, args, { signingOperationState: createSigningOperationStateRef({ operationId: createNearTransactionSigningOperationId() }) });
+		const operationId = createNearTransactionSigningOperationId();
+		emitEd25519SigningTiming(String(operationId), "preparation_modal", modalStartedAt);
+		return await signTransactionWithActionsAttempt(deps, args, { signingOperationState: createSigningOperationStateRef({ operationId }) });
 	} finally {
 		deps.touchConfirm.closeTransactionPreparationModal();
 	}
@@ -5574,12 +5450,14 @@ async function signTransactionWithActionsAttempt(deps, args, attempt) {
 	};
 	const confirmationOperationId = attempt.signingOperationState.operationId;
 	const signingSessionCoordinator = attempt.signingSessionCoordinator || deps.signingSessionCoordinator;
+	const authorizationProbeStartedAt = performance.now();
 	const authorizationRequired = await prepareNearAuthorizationRequiredTransaction({
 		deps,
 		input: args,
 		commandSubject: args.commandSubject,
 		operationId: confirmationOperationId
 	});
+	emitEd25519SigningTiming(String(confirmationOperationId), "authorization_probe", authorizationProbeStartedAt);
 	if (authorizationRequired) {
 		const ctx = deps.getSignerWorkerContext();
 		return await withThresholdEd25519CommitQueue({
@@ -5615,6 +5493,7 @@ async function signTransactionWithActionsAttempt(deps, args, attempt) {
 			})
 		});
 	}
+	const lanePreparationStartedAt = performance.now();
 	const preparedSigningSession = await prepareNearEd25519TransactionSigningSession({
 		deps,
 		input: args,
@@ -5623,6 +5502,8 @@ async function signTransactionWithActionsAttempt(deps, args, attempt) {
 		operationId: confirmationOperationId,
 		forceFreshAuth: attempt.forceFreshAuth === true
 	});
+	emitEd25519SigningTiming(String(confirmationOperationId), "lane_preparation", lanePreparationStartedAt);
+	const executionSetupStartedAt = performance.now();
 	const preparationAuthorization = preparedSigningSession.preparation.authorization;
 	const signingAuthPlan = preparedSigningSession.signingAuthPlan;
 	const signingLane = preparedSigningSession.signingLane;
@@ -5671,33 +5552,35 @@ async function signTransactionWithActionsAttempt(deps, args, attempt) {
 					signingAuthPlan: executionState.signingAuthPlan,
 					signingLane: executionState.signingLane
 				};
+				const payload = {
+					ctx,
+					commandSubject: args.commandSubject,
+					nearAccount,
+					transaction: args.transaction,
+					rpcCall: args.rpcCall,
+					signerSlot: publicOptions.signerSlot,
+					confirmationConfigOverride: publicOptions.confirmationConfigOverride,
+					title: publicOptions.title,
+					body: publicOptions.body,
+					onEvent: publicOptions.onEvent,
+					signingOperationState: attempt.signingOperationState,
+					signingSessionCoordinator: executionState.signingSessionCoordinator,
+					selection: {
+						kind: "authorized",
+						selectedLane: transactionLane
+					},
+					transactionOperation: executionState.transactionOperation,
+					ed25519SigningBoundary,
+					yaoSigningPreparation: materialBoundary.preparation,
+					yaoMaterialExecutor: materialBoundary.executor,
+					...executionState.passkeyEd25519OperationStepUp ? { passkeyEd25519OperationStepUp: executionState.passkeyEd25519OperationStepUp } : {},
+					...executionState.emailOtpEd25519StepUp ? { emailOtpEd25519StepUp: executionState.emailOtpEd25519StepUp } : {}
+				};
+				emitEd25519SigningTiming(String(confirmationOperationId), "execution_setup", executionSetupStartedAt);
 				return await signNearWithUiConfirm({
 					chain: "near",
 					kind: "transactionWithActions",
-					payload: {
-						ctx,
-						commandSubject: args.commandSubject,
-						nearAccount,
-						transaction: args.transaction,
-						rpcCall: args.rpcCall,
-						signerSlot: publicOptions.signerSlot,
-						confirmationConfigOverride: publicOptions.confirmationConfigOverride,
-						title: publicOptions.title,
-						body: publicOptions.body,
-						onEvent: publicOptions.onEvent,
-						signingOperationState: attempt.signingOperationState,
-						signingSessionCoordinator: executionState.signingSessionCoordinator,
-						selection: {
-							kind: "authorized",
-							selectedLane: transactionLane
-						},
-						transactionOperation: executionState.transactionOperation,
-						ed25519SigningBoundary,
-						yaoSigningPreparation: materialBoundary.preparation,
-						yaoMaterialExecutor: materialBoundary.executor,
-						...executionState.passkeyEd25519OperationStepUp ? { passkeyEd25519OperationStepUp: executionState.passkeyEd25519OperationStepUp } : {},
-						...executionState.emailOtpEd25519StepUp ? { emailOtpEd25519StepUp: executionState.emailOtpEd25519StepUp } : {}
-					}
+					payload
 				});
 			}
 		});
@@ -6007,4 +5890,4 @@ function reviewedNearContext(context, beforeSigning) {
 	};
 }
 //#endregion
-export { parseEmailOtpEcdsaExportWorkerIssuedSessionHandle as _, createSigningPlannerDecisionTraceEvent as a, nearImplicitAccountFundingPort as c, mintEd25519WalletSession as d, nearOperationStepUpPreparationPort as f, buildNearMessageDisplayModel as g, buildNearDisplayModel as h, withThresholdEd25519CommitQueue$1 as i, buildThresholdEd25519WebAuthnPrfSecretSource as l, getLastLoggedInSignerSlot as m, signNear_exports as n, planSigningSession as o, deriveThresholdEd25519ClientVerifyingShareWasm as p, resolveThresholdEd25519CommitQueueKey as r, parseAndValidateRegistrationCredentialConfirmationPayload as s, signNear as t, localPrfFirstForEd25519WalletSessionMintAuthorization as u, parseEmailOtpWorkerIssuedSessionHandle as v };
+export { isWorkerError as _, planSigningSession as a, parseEmailOtpEcdsaExportWorkerIssuedSessionHandle as b, buildThresholdEd25519WebAuthnPrfSecretSource as c, nearOperationStepUpPreparationPort as d, deriveThresholdEd25519ClientVerifyingShareWasm as f, DEFAULT_CONFIRMATION_CONFIG as g, buildNearMessageDisplayModel as h, createSigningPlannerDecisionTraceEvent as i, localPrfFirstForEd25519WalletSessionMintAuthorization as l, buildNearDisplayModel as m, signNear_exports as n, parseAndValidateRegistrationCredentialConfirmationPayload as o, getLastLoggedInSignerSlot as p, withThresholdEd25519CommitQueue$1 as r, nearImplicitAccountFundingPort as s, signNear as t, mintEd25519WalletSession as u, isWorkerProgress as v, parseEmailOtpWorkerIssuedSessionHandle as x, isWorkerSuccess as y };