@seams/wallet 0.8.0 → 0.9.0

package/dist/types/wallet/src/SeamsWeb/walletIframe/client/router.d.ts

@@ -1,36 +1,33 @@
+import type { AuthCapability } from '../../publicApi/types';
+import type { SigningEngineResolveExactKeyExportLaneInput as ResolveExactKeyExportLaneInput, SigningEngineResolveExactKeyExportLaneResult as ResolveExactKeyExportLaneResult } from '../../../core/signingEngine/flows/recovery/public';
+import { type WalletHostConfig } from '../shared/configuration';
 import { TransactionReviewReservation, type TransactionDispatch } from './transactionReviewReservation';
 import { type TransactionReviewValidity } from '../shared/transactionReview';
 import { type PreferencesChangedPayload } from '../shared/messages';
 import { SignedTransaction } from '../../../core/rpcClients/near/NearClient';
-import type { DigestB64u } from '../../../../../shared-ts/src/utils/canonicalPrimitives';
-import type { ActionHooksOptions, AfterCall, UnlockFlowEvent, RegistrationFlowEvent, SendTransactionHooksOptions, SignAndSendTransactionHooksOptions, SigningFlowEvent, AccountSyncFlowEvent, SdkLifecycleEventListener } from '../../../core/types/sdkSentEvents';
+import type { AfterCall, SendTransactionHooksOptions, SignAndSendTransactionHooksOptions, SigningFlowEvent, AccountSyncFlowEvent, SdkLifecycleEventListener } from '../../../core/types/sdkSentEvents';
 import type { WalletIframeTransportDiagnostics } from './transport/IframeTransport';
-import type { ActionResult, AppearanceConfigInput, GetRecentUnlocksResult, LoginAndCreateSessionResult, WalletSession, NearProvisioningState, RegistrationResult, SignDelegateActionResult, SignTransactionResult, SeamsChainConfig, SeamsConfigsInput } from '../../../core/types/seams';
+import type { ActionResult, AppearanceConfigInput, GetRecentUnlocksResult, LoginAndCreateSessionResult, WalletSession, NearProvisioningState, RegistrationResult, SignDelegateActionResult, SignTransactionResult } from '../../../core/types/seams';
 import type { MultichainSigningRequest } from '../../../core/signingEngine/chains/tempo/tempoSigning.types';
 import type { EvmSignedResult } from '../../../core/signingEngine/chains/evm/evmAdapter';
 import type { TempoSignedResult } from '../../../core/signingEngine/chains/tempo/tempoAdapter';
-import type { RouterAbEcdsaDerivationLoginPresignaturePrefillResult } from '../../../core/signingEngine/session/warmCapabilities/ecdsaLoginPrefill';
-import type { ThresholdEcdsaSessionBootstrapResult } from '../../../core/signingEngine/threshold/ecdsa/activation';
 import { type ThresholdEcdsaChainTarget, type WalletSessionRef } from '../../../core/signingEngine/interfaces/ecdsaChainTarget';
 import type { LinkDeviceResult, ScanAndLinkDeviceOptionsDevice1, StartDevice2LinkingFlowArgs, StartDevice2LinkingFlowResults } from '../../../core/types/linkDevice';
 import { type QrLinkedDeviceSessionPayloadV5, type LinkedDeviceListResultV1, type LinkedDeviceRevokeResultV1, type WalletSessionOperationCredentialV1 } from '../../../../../shared-ts/src/device-linking';
 import type { SyncAccountResult } from '../../operations/recovery/syncAccount';
 import type { SigningEngineExportKeypairWithUIInput as ExportKeypairWithUIInput } from '../../../core/signingEngine/flows/recovery/public';
-import type { FundImplicitNearAccountForTestingResult, ResolveExactKeyExportLaneInput, ResolveExactKeyExportLaneResult, AddPasskeyResult, AddEmailOtpResult, RevokeAuthMethodResult, ResumePendingEcdsaRegistrationResult, WalletRecoveryRotationOutcome } from '../../publicApi/types';
-import type { BootstrapThresholdEcdsaSessionArgs, EmailOtpChallengeResult, EmailOtpOperationChallengeResult, EmailOtpEcdsaCapabilityArgs, EmailOtpEcdsaCapabilityResult, EmailOtpEnrollmentResult, GoogleEmailOtpWalletAuthFlow, GoogleEmailOtpWalletAuthResult, GoogleEmailOtpWalletAuthStartInput, RecoveryCapability, RegistrationCapability } from '../../signingSurface/types';
+import type { AddPasskeyResult, AddEmailOtpResult, RevokeAuthMethodResult, WalletRecoveryRotationOutcome } from '../../publicApi/types';
+import type { GoogleEmailOtpWalletAuthFlow, GoogleEmailOtpWalletAuthResult, GoogleEmailOtpWalletAuthStartInput, RecoveryCapability, RegistrationCapability } from '../../signingSurface/types';
 import type { WalletRecoveryBackupAcknowledgementResult, WalletRecoveryCodeStatusResult, WalletCustodyEmailOtpChallengeResult } from '../../../core/rpcClients/relayer/walletRecoveryRotate';
-import type { HostedAuthMenuOpenRequest, HostedAuthMenuOutcome, HostedAuthMenuSessionId, HostedAuthMenuExternalAuthRequest, HostedAuthMenuExternalAuthResolutionInput, HostedAuthMenuDemoEmailOtpDelivery } from '../shared/messages';
-import { ActionArgs, TransactionInput } from '../../../core/types';
+import type { HostedAuthMenuOpenRequest, HostedAuthMenuOutcome, HostedAuthMenuSessionId, HostedAuthMenuExternalAuthRequest, HostedAuthMenuExternalAuthResolutionInput } from '../shared/messages';
+import { TransactionInput } from '../../../core/types';
 import type { DelegateActionInput } from '../../../core/types/delegate';
 import OverlayController, { type OverlayControllerState } from './overlay/overlay-controller';
-import { type WalletAuthMethodRevocationProof } from '../../../../../shared-ts/src/utils/walletAuthMethodRecord';
-import type { AuthenticatorOptions } from '../../../core/types/authenticatorOptions';
 import { type ConfirmationConfig } from '../../../core/types/signer-worker';
-import type { SignNEP413MessageResult } from '../../operations/near';
-import type { WalletEmailOtpLoginOperation } from '../../../../../shared-ts/src/utils/emailOtpDomain';
+import type { SignNEP413MessageResult } from '../../operations/near/signNEP413';
 import type { LoginUnlockRequest } from '../../../core/types/login.types';
 import type { WalletId } from '../../../../../shared-ts/src/utils/domainIds';
-import { type WalletIframeExactSessionIdentity, type WalletIframeExactSessionLockResult, type WalletIframeExactSessionState } from '../shared/exactSessionState';
+import { type WalletIframeExactSessionIdentity, type WalletIframeExactSessionLockResult, type WalletIframeExactSessionState, type WalletIframeSessionPublication } from '../shared/exactSessionState';
 interface WalletIframeRouterOptions {
     walletOrigin: string;
     servicePath?: string;
@@ -42,17 +39,7 @@ interface WalletIframeRouterOptions {
         ownerTag?: string;
         autoMount?: boolean;
     };
-    chains?: readonly SeamsChainConfig[];
-    relayerAccount?: string;
-    relayer?: SeamsConfigsInput['relayer'];
-    registration?: SeamsConfigsInput['registration'];
-    signingSessionDefaults?: SeamsConfigsInput['signingSessionDefaults'];
-    signingSessionPersistenceMode?: SeamsConfigsInput['signingSessionPersistenceMode'];
-    routerAb?: SeamsConfigsInput['routerAb'];
-    routerAbEcdsaDerivationPresignaturePool?: SeamsConfigsInput['routerAbEcdsaDerivationPresignaturePool'];
-    provisioningDefaults?: SeamsConfigsInput['provisioningDefaults'];
-    rpIdOverride?: string;
-    authenticatorOptions?: AuthenticatorOptions;
+    hostConfig: WalletHostConfig;
     sdkBasePath?: string;
     appearance?: AppearanceConfigInput;
     getAppearance?: () => AppearanceConfigInput | undefined;
@@ -76,12 +63,16 @@ type HostedWalletSeamsSessionSource = {
     readonly operationCredential: WalletSessionOperationCredentialV1;
 };
 export declare class WalletIframeRouter {
+    readonly placement: import("../../..").WalletPlacementCapability;
+    private readonly walletSessionReads;
     private opts;
     private transport;
     private state;
     private readonly listeners;
     private readonly expiredSigningSessionsByWallet;
     private exactSessionState;
+    private sessionSelectionGeneration;
+    private sessionObservationRevision;
     private lastPreferencesChangedPayload;
     private mirroredConfirmationUiMode;
     private progressBus;
@@ -172,15 +163,9 @@ export declare class WalletIframeRouter {
     private handleConnectionClosed;
     private hideRequestSurface;
     private finishDeviceLinkQrSurface;
-    /**
-     * Subscribe to service-ready event. Returns an unsubscribe function.
-     * If already ready, the listener is invoked on next microtask.
-     */
-    onReady(listener: () => void): () => void;
+    onConnectionClosed(listener: () => void): () => void;
     onHostedAuthMenuExternalAuthRequest(listener: (payload: HostedAuthMenuExternalAuthRequest) => void): () => void;
-    onHostedAuthMenuDemoEmailOtpDelivery(listener: (payload: HostedAuthMenuDemoEmailOtpDelivery) => void): () => void;
     resolveHostedAuthMenuExternalAuth(resolution: HostedAuthMenuExternalAuthResolutionInput): Promise<void>;
-    private emitReady;
     /**
      * Initialize the transport and configure the wallet host.
      * Safe to call multiple times; concurrent calls deduplicate via initInFlight.
@@ -195,18 +180,15 @@ export declare class WalletIframeRouter {
     private exchangeHostedWalletSeamsSession;
     getTransportDiagnosticsSnapshot(): WalletIframeTransportDiagnostics;
     dispose(): void;
-    onLoginStatusChanged(listener: (status: {
-        isLoggedIn: boolean;
-        walletId: string | null;
-    }) => void): () => void;
+    onSessionChange(listener: (state: WalletIframeExactSessionState, publication: WalletIframeSessionPublication) => void): () => void;
     onPreferencesChanged(listener: (payload: PreferencesChangedPayload) => void): () => void;
     onSdkLifecycleEvent(listener: SdkLifecycleEventListener): () => void;
     getMirroredExactSessionState(): WalletIframeExactSessionState;
     getExactSessionState(): Promise<WalletIframeExactSessionState>;
     private refreshExactSessionState;
-    private emitLoginStatusChanged;
-    private mirrorExactSessionAndEmitLoginStatus;
-    private refreshExactSessionAndEmitLoginStatus;
+    private acceptSessionSnapshot;
+    private emitSessionChanged;
+    private refreshExactSessionAndEmitChange;
     private emitPreferencesChanged;
     private notifyPreferencesChangedListener;
     private handlePreferencesChanged;
@@ -214,7 +196,7 @@ export declare class WalletIframeRouter {
     private mirrorExpiredSession;
     private failPendingRequestsForExpiredSession;
     private markSigningSessionExpiryAsNew;
-    signTransactionWithActions(payload: {
+    signTransaction(payload: {
         walletId: string;
         nearAccountId: string;
         transaction: TransactionInput;
@@ -247,70 +229,24 @@ export declare class WalletIframeRouter {
         };
     }): Promise<SignDelegateActionResult>;
     registerWallet(payload: Parameters<RegistrationCapability['registerWallet']>[0]): Promise<RegistrationResult>;
-    getNearProvisioningState(args: {
+    getNearAccountState(args: {
         walletId: WalletId | string;
     }): Promise<NearProvisioningState | null>;
-    resumePendingEcdsaRegistration(args: Parameters<RegistrationCapability['resumePendingEcdsaRegistration']>[0]): Promise<ResumePendingEcdsaRegistrationResult>;
-    addWalletSigner(payload: Parameters<RegistrationCapability['addWalletSigner']>[0]): Promise<RegistrationResult>;
+    addSigner(payload: Parameters<RegistrationCapability['addSigner']>[0]): Promise<RegistrationResult>;
     addPasskey(payload: Parameters<RegistrationCapability['addPasskey']>[0]): Promise<AddPasskeyResult>;
-    addEmailOtp(payload: Parameters<RegistrationCapability['addEmailOtp']>[0]): Promise<AddEmailOtpResult>;
-    revokeAuthMethod(payload: Parameters<RegistrationCapability['revokeAuthMethod']>[0]): Promise<RevokeAuthMethodResult>;
-    bootstrapEcdsaSession(payload: BootstrapThresholdEcdsaSessionArgs): Promise<ThresholdEcdsaSessionBootstrapResult>;
+    addEmail(payload: Parameters<RegistrationCapability['addEmail']>[0]): Promise<AddEmailOtpResult>;
+    removeAuthMethod(payload: Parameters<RegistrationCapability['removeAuthMethod']>[0]): Promise<RevokeAuthMethodResult>;
     unlock(payload: LoginUnlockRequest): Promise<LoginAndCreateSessionResult>;
     getWalletSession(walletId?: string): Promise<WalletSession>;
-    requestEmailOtpChallenge(payload: {
-        walletId: string;
-        walletAuthMethodId?: string;
-        relayUrl?: string;
-        operation?: WalletEmailOtpLoginOperation;
-        operationFingerprintDigest?: DigestB64u;
-        onEvent?: (ev: UnlockFlowEvent) => void;
-    }): Promise<EmailOtpOperationChallengeResult>;
-    requestEmailOtpEnrollmentChallenge(payload: {
-        walletId: string;
-        relayUrl?: string;
-        onEvent?: (ev: RegistrationFlowEvent) => void;
-    }): Promise<EmailOtpChallengeResult>;
-    requestEmailOtpSigningSessionChallenge(payload: {
-        walletSession: WalletSessionRef;
-        chainTarget: ThresholdEcdsaChainTarget;
-        onEvent?: (ev: UnlockFlowEvent) => void;
-    }): Promise<Pick<EmailOtpChallengeResult, 'challengeId' | 'emailHint'>>;
+    private finishWalletSessionRead;
+    private readWalletSession;
+    requestEmailCode(payload: Parameters<AuthCapability['requestEmailCode']>[0]): ReturnType<AuthCapability['requestEmailCode']>;
     private googleEmailOtpWalletAuthFlowFromWire;
-    beginGoogleEmailOtpWalletAuth(payload: GoogleEmailOtpWalletAuthStartInput): Promise<GoogleEmailOtpWalletAuthResult<GoogleEmailOtpWalletAuthFlow>>;
-    enrollEmailOtp(payload: {
-        walletId: string;
-        otpCode: string;
-        relayUrl?: string;
-        challengeId?: string;
-        groupId?: string;
-        onEvent?: (ev: RegistrationFlowEvent) => void;
-    }): Promise<EmailOtpEnrollmentResult>;
-    unlockAddedEmailOtpWallet(payload: {
-        walletId: string;
-        walletAuthMethodId: string;
-        email: string;
-        providerSubjectId: string;
-        challengeId: string;
-        otpCode: string;
-        relayUrl: string;
-    }): Promise<void>;
-    loginWithEmailOtpEcdsaCapability(payload: EmailOtpEcdsaCapabilityArgs & {
-        publicationChainTargets?: readonly ThresholdEcdsaChainTarget[];
-    }): Promise<EmailOtpEcdsaCapabilityResult>;
-    refreshEmailOtpSigningSession(payload: {
-        walletSession: WalletSessionRef;
-        chainTarget: ThresholdEcdsaChainTarget;
-        challengeId: string;
-        otpCode: string;
-        ttlMs?: number;
-        remainingUses?: number;
-        onEvent?: (ev: UnlockFlowEvent) => void;
-    }): Promise<EmailOtpEcdsaCapabilityResult>;
-    getWalletRecoveryCodeStatus(payload: {
+    startGoogleSignIn(payload: GoogleEmailOtpWalletAuthStartInput): Promise<GoogleEmailOtpWalletAuthResult<GoogleEmailOtpWalletAuthFlow>>;
+    getCodeStatus(payload: {
         walletId: string;
     }): Promise<WalletRecoveryCodeStatusResult>;
-    acknowledgeWalletRecoveryCodeBackup(payload: {
+    confirmBackup(payload: {
         walletId: string;
     }): Promise<WalletRecoveryBackupAcknowledgementResult>;
     requestWalletCustodyEmailOtpChallenge(payload: {
@@ -320,16 +256,16 @@ export declare class WalletIframeRouter {
         payload: Record<string, unknown>;
         requestOrigin?: string;
     }): Promise<WalletCustodyEmailOtpChallengeResult>;
-    rotateWalletRecoveryCodes(payload: Parameters<RecoveryCapability['rotateWalletRecoveryCodes']>[0]): Promise<WalletRecoveryRotationOutcome>;
+    rotateCodes(payload: Parameters<RecoveryCapability['rotateCodes']>[0]): Promise<WalletRecoveryRotationOutcome>;
     checkLoginStatus(): Promise<PostResult<WalletIframeLoginStatusSnapshot>>;
     lock(): Promise<PostResult<void>>;
-    logout(): Promise<PostResult<void>>;
     lockExactSession(expected: WalletIframeExactSessionIdentity): Promise<WalletIframeExactSessionLockResult>;
     signNep413Message(payload: {
         walletId: string;
         nearAccountId: string;
         message: string;
         recipient: string;
+        callbackUrl?: string;
         state?: string;
         options: {
             signerSlot?: number;
@@ -401,16 +337,10 @@ export declare class WalletIframeRouter {
         blocked: boolean;
         blockedNonce?: string;
     }>;
-    executeAction(payload: {
-        walletId: string;
-        nearAccountId: string;
-        receiverId: string;
-        actionArgs: ActionArgs | ActionArgs[];
-        options: ActionHooksOptions;
-    }, transactionDispatch?: TransactionDispatch): Promise<ActionResult>;
-    setConfirmBehavior(behavior: 'requireClick' | 'skipClick', walletId?: string | null): Promise<void>;
+    setConfirmationBehavior(behavior: 'requireClick' | 'skipClick', walletId?: string | null): Promise<void>;
     setConfirmationConfig(config: Partial<ConfirmationConfig>, walletId?: string | null): Promise<void>;
     getConfirmationConfig(): Promise<ConfirmationConfig>;
+    private requestPreferences;
     /**
      * Push appearance (theme name and/or color token overrides) to the wallet
      * host at runtime. The host merges this with prior config and re-applies the
@@ -419,14 +349,6 @@ export declare class WalletIframeRouter {
      * fingerprint, so this never drops warm signing-session state.
      */
     setAppearance(appearance: AppearanceConfigInput): Promise<void>;
-    prefetchBlockheight(): Promise<void>;
-    prefillRouterAbEcdsaDerivationPresignaturePool(payload: {
-        walletSession: WalletSessionRef;
-        options: {
-            chainTarget: ThresholdEcdsaChainTarget;
-            waitForPoolReady?: boolean;
-        };
-    }): Promise<RouterAbEcdsaDerivationLoginPresignaturePrefillResult>;
     getRecentUnlocks(): Promise<GetRecentUnlocksResult>;
     syncAccount(payload: {
         walletId?: string;
@@ -452,11 +374,6 @@ export declare class WalletIframeRouter {
         transaction: TransactionInput;
         options: SignAndSendTransactionHooksOptions;
     }, transactionDispatch?: TransactionDispatch): Promise<ActionResult>;
-    fundImplicitNearAccountForTesting(payload: {
-        walletId: string;
-        nearAccountId: string;
-        nearPublicKey: string;
-    }): Promise<FundImplicitNearAccountForTestingResult>;
     hasPasskeyCredential(walletId: string): Promise<boolean>;
     listLinkedDevices(payload: {
         walletId: string;
@@ -466,8 +383,6 @@ export declare class WalletIframeRouter {
     revokeLinkedDevice(payload: {
         walletId: string;
         walletAuthMethodId: string;
-        requestedAtMs: number;
-        sourceProof: WalletAuthMethodRevocationProof;
     }): Promise<LinkedDeviceRevokeResultV1>;
     sendTransaction(args: {
         walletId: string;

package/dist/types/wallet/src/SeamsWeb/walletIframe/client/sessionCommands.d.ts

@@ -0,0 +1,6 @@
+import type { WalletSessionCommands } from '../../publicApi/auth';
+import type { WalletIframeCoordinator } from '../coordinator';
+type SessionIframe = Pick<WalletIframeCoordinator, 'requireRouter'>;
+export declare function createApplicationSessionCommands(walletIframe: SessionIframe): WalletSessionCommands;
+export {};
+//# sourceMappingURL=sessionCommands.d.ts.map

package/dist/types/wallet/src/SeamsWeb/walletIframe/coordinator.d.ts

@@ -1,16 +1,14 @@
-import type { UserPreferencesManager } from '../../core/signingEngine/session/userPreferences';
-import type { AppearanceConfig, SeamsConfigsReadonly } from '../../core/types/seams';
+import type { ClientConnectionState } from '../publicApi/types';
+import type { PreferenceState } from './client/preferenceState';
+import type { AppearanceConfig, SeamsClientConfig, WalletSession } from '../../core/types/seams';
 import type { WalletIframeRouter } from './client/router';
 import type { WalletIframeTransportDiagnostics } from './client/transport/IframeTransport';
-import type { HostedAuthMenuExternalAuthRequest, HostedAuthMenuDemoEmailOtpDelivery, HostedAuthMenuExternalAuthResolutionInput, HostedAuthMenuOpenRequest, HostedAuthMenuOutcome, HostedAuthMenuSessionId, PreferencesChangedPayload } from './shared/messages';
-import type { WalletIframeWarmupSurface } from '../signingSurface/types';
-import { type WebAuthnRpId } from '../../../../shared-ts/src/utils/domainIds';
+import type { HostedAuthMenuExternalAuthRequest, HostedAuthMenuExternalAuthResolutionInput, HostedAuthMenuOpenRequest, HostedAuthMenuOutcome, HostedAuthMenuSessionId } from './shared/messages';
 import type { SdkLifecycleEventListener } from '../../core/types/sdkSentEvents';
 import type { WalletIframeExactSessionIdentity, WalletIframeExactSessionLockResult, WalletIframeExactSessionState } from './shared/exactSessionState';
 interface WalletIframeCoordinatorDeps {
-    configs: SeamsConfigsReadonly;
-    signingEngine: WalletIframeWarmupSurface;
-    userPreferences: UserPreferencesManager;
+    configs: SeamsClientConfig;
+    userPreferences: PreferenceState;
     getAppearance: () => AppearanceConfig;
 }
 /**
@@ -19,53 +17,51 @@ interface WalletIframeCoordinatorDeps {
  */
 export declare class WalletIframeCoordinator {
     private readonly configs;
-    private readonly signingEngine;
     private readonly userPreferences;
     private readonly getAppearance;
     private iframeRouter;
-    private walletIframeRouterCreationInFlight;
-    private walletIframeInitInFlight;
-    private walletIframeDisposed;
+    private connection;
+    private connectionGeneration;
+    private readonly connectionListeners;
+    private walletIframeCloseUnsubscribe;
     private walletIframePrefsUnsubscribe;
+    private sessionDeliveryRevision;
+    private walletIframeSessionUnsubscribe;
+    private readonly sessionListeners;
     private walletIframeLifecycleUnsubscribe;
     private walletIframeAuthMenuUnsubscribe;
-    private walletIframeAuthMenuDemoOtpUnsubscribe;
     private readonly sdkLifecycleEventListeners;
     private readonly hostedAuthMenuExternalAuthRequestListeners;
-    private readonly hostedAuthMenuDemoEmailOtpDeliveryListeners;
     private readonly forwardSdkLifecycleEventListener;
     private readonly forwardHostedAuthMenuExternalAuthRequestListener;
-    private readonly forwardHostedAuthMenuDemoEmailOtpDeliveryListener;
     constructor(deps: WalletIframeCoordinatorDeps);
-    /**
-     * True when the SDK is running on the app origin with a wallet iframe configured.
-     * In this mode, sensitive persistence must live in the wallet-iframe origin.
-     */
-    shouldUseWalletIframe(): boolean;
-    resolveRegistrationRpId(localRpId: string): WebAuthnRpId;
-    isReady(): boolean;
+    getConnectionState(): ClientConnectionState;
+    onConnectionChange(listener: (state: ClientConnectionState) => void): () => void;
+    private deliverConnectionState;
+    private setConnection;
     getTransportDiagnosticsSnapshot(): WalletIframeTransportDiagnostics | null;
     dispose(): void;
-    onReady(listener: () => void): () => void;
-    onLoginStatusChanged(listener: (status: {
-        isLoggedIn: boolean;
-        walletId: string | null;
-    }) => void): () => void;
+    private releaseRouter;
+    private connectionClosed;
+    onSessionChange(listener: (session: WalletSession) => void): () => void;
+    private refreshSession;
+    private publishSessionChange;
+    private reportSessionFailure;
+    private publishSession;
+    private deliverSession;
     onSdkLifecycleEvent(listener: SdkLifecycleEventListener): () => void;
-    onPreferencesChanged(listener: (payload: PreferencesChangedPayload) => void): () => void;
-    init(_walletId?: string): Promise<WalletIframeExactSessionState>;
+    connect(): Promise<void>;
+    private initializeConnection;
+    private assertConnecting;
     getExactSessionState(): Promise<WalletIframeExactSessionState>;
     openHostedAuthMenu(request: HostedAuthMenuOpenRequest, anchorElement?: HTMLElement): Promise<HostedAuthMenuOutcome>;
     cancelHostedAuthMenu(args: {
         authMenuSessionId: HostedAuthMenuSessionId;
     }): Promise<void>;
     onHostedAuthMenuExternalAuthRequest(listener: (request: HostedAuthMenuExternalAuthRequest) => void): () => void;
-    onHostedAuthMenuDemoEmailOtpDelivery(listener: (delivery: HostedAuthMenuDemoEmailOtpDelivery) => void): () => void;
     resolveHostedAuthMenuExternalAuth(resolution: HostedAuthMenuExternalAuthResolutionInput): Promise<void>;
     lockExactSession(identity: WalletIframeExactSessionIdentity): Promise<WalletIframeExactSessionLockResult>;
-    requireRouter(walletId?: string): Promise<WalletIframeRouter>;
-    requireTransportRouter(): Promise<WalletIframeRouter>;
-    private getOrCreateRouter;
+    requireRouter(): Promise<WalletIframeRouter>;
     private ensureWalletIframePreferencesMirror;
     private ensureWalletIframeLifecycleMirror;
     private ensureWalletIframeAuthMenuMirror;
@@ -73,8 +69,6 @@ export declare class WalletIframeCoordinator {
     private removeSdkLifecycleEventListener;
     private forwardHostedAuthMenuExternalAuthRequest;
     private removeHostedAuthMenuExternalAuthRequestListener;
-    private forwardHostedAuthMenuDemoEmailOtpDelivery;
-    private removeHostedAuthMenuDemoEmailOtpDeliveryListener;
 }
 export {};
 //# sourceMappingURL=coordinator.d.ts.map

package/dist/types/wallet/src/SeamsWeb/walletIframe/host/WalletHostRuntime.d.ts

@@ -0,0 +1,98 @@
+import type { WalletPlacementCapability } from '../../publicApi/placement';
+import { type KeyExportDomainMethods } from '../../publicApi/keyExport';
+import type { WalletAuthCommands } from '../../publicApi/auth';
+import type { UserPreferencesManager } from '../../../core/signingEngine/session/userPreferences';
+import type { WalletHostConfig } from '../shared/configuration';
+import type { TempoChainTarget } from '../../../core/platform/types';
+import { type NearClient } from '../../../core/rpcClients/near/NearClient';
+import type { EvmSignedResult } from '../../../core/signingEngine/chains/evm/evmAdapter';
+import { type TempoFeeTokenPreferenceSigningRequest } from '../../../core/signingEngine/chains/tempo/feeToken';
+import { type ThresholdEcdsaChainTarget, type WalletSessionRef } from '../../../core/signingEngine/interfaces/ecdsaChainTarget';
+import type { UiConfirmSurfaceMeasurementBinding } from '../../../core/signingEngine/uiConfirm/uiConfirm.types';
+import type { SdkLifecycleEventListener, SigningFlowEvent } from '../../../core/types/sdkSentEvents';
+import type { AppearanceConfigInput, ThemeMode } from '../../../core/types/seams';
+import type { ConfirmationConfig } from '../../../core/types/signer-worker';
+import { type EcdsaChainSelector } from '../../publicApi/chainTargets';
+import type { DevicesCapability, EvmSignerCapability, NearSignerCapability, PreferencesCapability, RecoveryCapability, RegistrationCapability, SeamsWebContext, TempoSignerCapability } from '../../signingSurface/types';
+import { type WalletIframeExactSessionState } from '../shared/exactSessionState';
+type SeamsWebContextWithDeviceLinkingResumeV1 = SeamsWebContext & {
+    readonly resumePendingAcknowledgementsV1: () => void;
+};
+/** Owns wallet-origin execution and durable signing state. */
+export declare class WalletHostRuntime {
+    private readonly signingEngine;
+    private readonly nearClient;
+    readonly configs: WalletHostConfig;
+    private appearance;
+    theme: ThemeMode;
+    private readonly prefillRestoredSession;
+    readonly recovery: RecoveryCapability;
+    readonly devices: DevicesCapability;
+    readonly keys: KeyExportDomainMethods;
+    readonly preferences: Omit<PreferencesCapability, 'setConfirmationConfig' | 'setConfirmationBehavior' | 'onCurrentWalletChange'> & Pick<UserPreferencesManager, 'setConfirmationConfig' | 'setConfirmationBehavior' | 'onCurrentWalletChange'>;
+    readonly auth: WalletAuthCommands;
+    readonly placement: WalletPlacementCapability;
+    readonly registration: RegistrationCapability;
+    readonly near: NearSignerCapability;
+    readonly tempo: TempoSignerCapability;
+    readonly evm: EvmSignerCapability;
+    private readonly deviceLinkingDispose;
+    private readonly resumePendingAcknowledgementsV1;
+    constructor(configs: WalletHostConfig, nearClient?: NearClient);
+    /** @internal One wallet-host restore owns all configured-chain prefills. */
+    prefillRestoredWalletSession(state: WalletIframeExactSessionState): Promise<void>;
+    private lockAfterWalletMove;
+    /** Subscribe to typed lifecycle events emitted by the wallet boundary. */
+    onSdkLifecycleEvent(listener: SdkLifecycleEventListener): () => void;
+    getContext(): SeamsWebContextWithDeviceLinkingResumeV1;
+    private resumePendingAcknowledgementsAfterExactUnlockV1;
+    private resumePendingRegistrationOnStartup;
+    dispose(): void;
+    setTheme(next: ThemeMode): void;
+    /**
+     * Resolve one configured ECDSA chain target by network slug, chain id, or
+     * family — the value every EVM-family signing and export call takes.
+     *
+     * Throws when the selector matches no configured chain, or more than one.
+     * Every configured chain is named in the error, so an ambiguous selector is
+     * a clear failure rather than a silent first-match pick.
+     *
+     * @example seams.config.chainTarget('tempo-testnet')
+     */
+    chainTarget(selector: EcdsaChainSelector): ThresholdEcdsaChainTarget;
+    /** Every ECDSA chain target this client is configured for. */
+    configuredChainTargets(): readonly ThresholdEcdsaChainTarget[];
+    /**
+     * Update resolved appearance at runtime.
+     * This is the canonical internal propagation path for local signing UI,
+     * wallet-host documents, and app-origin wallet iframe mode. Appearance is
+     * excluded from the runtime-reset fingerprint, so warm signing-session state
+     * is preserved. Fire-and-forget; never throws.
+     */
+    setAppearance(appearance: AppearanceConfigInput): void;
+    setWalletIframeSurfaceMeasurementBinding(binding: UiConfirmSurfaceMeasurementBinding): void;
+    private syncAccountDomain;
+    private onNearAccountChange;
+    private getCodeStatusDomain;
+    private confirmBackupDomain;
+    private loadPendingWalletRecoveryCodeBackupRequest;
+    private requestWalletCustodyEmailOtpChallengeDomain;
+    private rotateCodesDomain;
+    /** Wallet-host entrypoint for the exact FeeManager preference operation. */
+    signTempoFeeTokenPreferenceInternal(args: {
+        walletSession: WalletSessionRef;
+        request: TempoFeeTokenPreferenceSigningRequest;
+        chainTarget: TempoChainTarget;
+        confirmationConfigOverride?: Partial<ConfirmationConfig>;
+        shouldAbort?: () => boolean;
+        onEvent?: (event: SigningFlowEvent) => void;
+    }): Promise<EvmSignedResult>;
+    /**
+     * Canonical entrypoint to show secure key export UI (wallet-origin only) without
+     * returning private keys to the caller.
+     */
+    private resolveExactKeyExportLaneDomain;
+    private exportKeypairWithUIDomain;
+}
+export {};
+//# sourceMappingURL=WalletHostRuntime.d.ts.map

package/dist/types/wallet/src/SeamsWeb/walletIframe/host/auth-menu/controller.d.ts

@@ -1,8 +1,8 @@
 import type { AppearanceConfig } from '../../../../core/types/seams';
-import type { SeamsWeb } from '../../..';
+import type { WalletHostRuntime } from '../WalletHostRuntime';
 import type { ChildToParentEnvelope, HostedAuthMenuCancelPayload, HostedAuthMenuExternalAuthResolution, HostedAuthMenuOpenRequest } from '../../shared/messages';
 type AuthMenuControllerDeps = {
-    readonly getSeamsWeb: () => SeamsWeb;
+    readonly getWalletRuntime: () => WalletHostRuntime;
     readonly getAppearance: () => AppearanceConfig;
     readonly send: (message: ChildToParentEnvelope) => void;
 };

package/dist/types/wallet/src/SeamsWeb/walletIframe/host/context.d.ts

@@ -1,27 +1,29 @@
+import type { WalletHostSessionObserver } from './sessionObserver';
 import { MinimalNearClient } from '../../../core/rpcClients/near/NearClient';
-import { SeamsWeb } from '../..';
-import type { SeamsConfigsInput } from '../../../core/types/seams';
-import type { PMSetConfigPayload } from '../shared/messages';
+import { WalletHostRuntime } from './WalletHostRuntime';
 import type { SdkLifecycleEventListener } from '../../../core/types/sdkSentEvents';
 import type { UiConfirmSurfaceMeasurementBinding } from '../../../core/signingEngine/uiConfirm/uiConfirm.types';
 import type { WalletSessionId } from '../../../core/types/sdkSentEvents';
 import type { WalletId } from '../../../../../shared-ts/src/utils/domainIds';
+import type { ConfiguredWalletHost, WalletHostConfigurationState } from '../shared/configuration';
 export interface HostContext {
     parentOrigin: string | null;
     port: MessagePort | null;
-    walletConfigs: SeamsConfigsInput | null;
+    configuration: WalletHostConfigurationState;
+    preferencesRevision: number;
+    sessionObserver: WalletHostSessionObserver | null;
     nearClient: MinimalNearClient | null;
-    seamsWeb: SeamsWeb | null;
+    walletRuntime: WalletHostRuntime | null;
     prefsUnsubscribe?: (() => void) | null;
-    lifecycleSource: SeamsWeb | null;
+    lifecycleSource: WalletHostRuntime | null;
     lifecycleUnsubscribe: (() => void) | null;
     lifecycleListener: SdkLifecycleEventListener | null;
     expiredSessionsByWallet: Map<WalletId, Set<WalletSessionId>>;
     surfaceMeasurementBinding: UiConfirmSurfaceMeasurementBinding;
 }
 export declare function createHostContext(): HostContext;
-export declare function ensureSeamsWeb(ctx: HostContext): SeamsWeb;
-export declare function applyWalletConfig(ctx: HostContext, payload: PMSetConfigPayload): void;
-export declare function ensureWalletHostLifecycleSubscription(ctx: HostContext, pm: SeamsWeb): void;
+export declare function ensureWalletRuntime(ctx: HostContext): WalletHostRuntime;
+export declare function applyWalletConfig(ctx: HostContext, configuration: ConfiguredWalletHost): void;
+export declare function ensureWalletHostLifecycleSubscription(ctx: HostContext, pm: WalletHostRuntime): void;
 export declare function setWalletHostLifecycleListener(ctx: HostContext, listener: SdkLifecycleEventListener): void;
 //# sourceMappingURL=context.d.ts.map

package/dist/types/wallet/src/SeamsWeb/walletIframe/host/createDeviceDomain.d.ts

@@ -0,0 +1,20 @@
+import type { BrowserSigningSurface } from '../../signingSurface/BrowserSigningSurface';
+import type { SeamsConfigsReadonly } from '../../../core/types/seams';
+import type { DeviceCommands } from '../../publicApi/devices';
+import type { DeviceLinkingWebContext } from '../../signingSurface/types';
+import type { createBrowserHostPlatformRuntime } from '../../assembly/createBrowserSigningRuntime';
+import type { WalletHostOwnerAuthoritiesV1 } from '../../operations/devices/walletHostOwnerAuthority';
+type WalletHostDeviceDomain = {
+    readonly domain: DeviceCommands;
+    readonly resumePendingAcknowledgementsV1: () => Promise<void>;
+    readonly dispose: () => void;
+};
+export declare function createWalletHostDeviceDomain(args: {
+    readonly configs: SeamsConfigsReadonly;
+    readonly signingEngine: BrowserSigningSurface;
+    readonly getContext: () => DeviceLinkingWebContext;
+    readonly platform: ReturnType<typeof createBrowserHostPlatformRuntime>;
+    readonly ownerAuthorities: WalletHostOwnerAuthoritiesV1;
+}): WalletHostDeviceDomain;
+export {};
+//# sourceMappingURL=createDeviceDomain.d.ts.map

package/dist/types/wallet/src/SeamsWeb/walletIframe/host/createEmailOtpCommands.d.ts

@@ -0,0 +1,11 @@
+import type { AuthCapability, SeamsWebContext, RegistrationCapability } from '../../signingSurface/types';
+import { type EmailOtpAuthCommands } from '../../publicApi/auth';
+type HostEmailOtpDependencies = {
+    getContext: () => SeamsWebContext;
+    registerWallet: RegistrationCapability['registerWallet'];
+    getWalletSession: AuthCapability['getSession'];
+    resumePendingAcknowledgements: () => void;
+};
+export declare function createWalletHostEmailOtpCommands(deps: HostEmailOtpDependencies): EmailOtpAuthCommands;
+export {};
+//# sourceMappingURL=createEmailOtpCommands.d.ts.map

package/dist/types/wallet/src/SeamsWeb/walletIframe/host/createEvmFamilyCommands.d.ts

@@ -0,0 +1,8 @@
+import type { EvmFamilyCommands } from '../../publicApi/evmFamilyCommands';
+import type { TempoSigningSurface } from '../../signingSurface/types';
+type EvmFamilyHostContext = {
+    signingEngine: TempoSigningSurface;
+};
+export declare function createWalletHostEvmFamilyCommands(getContext: () => EvmFamilyHostContext): EvmFamilyCommands;
+export {};
+//# sourceMappingURL=createEvmFamilyCommands.d.ts.map

package/dist/types/wallet/src/SeamsWeb/walletIframe/host/createNearCommands.d.ts

@@ -0,0 +1,4 @@
+import type { NearCommands } from '../../publicApi/nearCommands';
+import type { NearSigningWebContext } from '../../signingSurface/types';
+export declare function createWalletHostNearCommands(getContext: () => NearSigningWebContext): NearCommands;
+//# sourceMappingURL=createNearCommands.d.ts.map

package/dist/types/wallet/src/SeamsWeb/walletIframe/host/createPlacementCommands.d.ts

@@ -0,0 +1,11 @@
+import { type WalletPlacementSession } from './reconcileWalletPlacement';
+import type { BrowserSigningSurface } from '../../signingSurface/BrowserSigningSurface';
+import { type WalletPlacementCapability } from '../../publicApi/placement';
+import type { WalletHostManagementRequestV1 } from '../../operations/devices/walletHostOwnerAuthority';
+type Context = WalletPlacementSession & {
+    readonly signingEngine: BrowserSigningSurface;
+    readonly managementRequest: WalletHostManagementRequestV1;
+};
+export declare function createWalletHostPlacementCommands(context: Context): WalletPlacementCapability;
+export {};
+//# sourceMappingURL=createPlacementCommands.d.ts.map

package/dist/types/wallet/src/SeamsWeb/walletIframe/host/createRegistrationCommands.d.ts

@@ -0,0 +1,4 @@
+import type { RegistrationWebContext } from '../../signingSurface/types';
+import type { WalletRegistrationCommands } from '../../publicApi/createPublicApi';
+export declare function createWalletHostRegistrationCommands(getContext: () => RegistrationWebContext): WalletRegistrationCommands;
+//# sourceMappingURL=createRegistrationCommands.d.ts.map