@seams/wallet 0.26.0 → 0.27.0

package/dist/.build-inputs.sha256

@@ -1 +1 @@
-5e18387096278925c5c1f4c69f379b59f0eab2e662d419fe575bee269eb216df
+454b5591bcd47936d9aea9092966bd446c1e755578e6e1accdd9831099483a70

package/dist/esm/SeamsWeb/publicApi/near.js

@@ -1,5 +1,6 @@
 import { CAPABILITY_KINDS, NEAR_ED25519_MPC_OPERATION_KINDS } from "../../shared-ts/src/authorization/capabilityKinds.js";
 import { toError } from "../../shared-ts/src/utils/errors.js";
+import { nearTransactionFailure } from "../../core/signingEngine/nearTransactionSubmission.js";
 import { requireBrowserCapabilityOperation } from "./capabilitySelection.js";
 import { accountExists } from "../../core/rpcClients/near/accountExists.js";
 import { delegateRelayerAuthFromConfigs, sendDelegateAction } from "../operations/near/delegateAction.js";
@@ -23,16 +24,21 @@ var NearSigner = class {
 		this.deps = deps;
 	}
 	async signAndSendTransaction(rawArgs) {
-		const args = {
+		let subject;
+		try {
+			subject = await this.deps.currentWallet.nearSubject(rawArgs);
+			requireBrowserCapabilityOperation(this.deps.configs, {
+				capabilityKind: CAPABILITY_KINDS.nearEd25519MpcSigning,
+				operationKind: NEAR_ED25519_MPC_OPERATION_KINDS.signTransaction
+			});
+		} catch (error) {
+			return nearTransactionFailure(error, "not_submitted");
+		}
+		return this.deps.commands.signAndSendTransaction({
 			...rawArgs,
-			...await this.deps.currentWallet.nearSubject(rawArgs),
+			...subject,
 			options: rawArgs.options ?? {}
-		};
-		requireBrowserCapabilityOperation(this.deps.configs, {
-			capabilityKind: CAPABILITY_KINDS.nearEd25519MpcSigning,
-			operationKind: NEAR_ED25519_MPC_OPERATION_KINDS.signTransaction
 		});
-		return await this.deps.commands.signAndSendTransaction(args);
 	}
 	async signTransaction(rawArgs) {
 		const args = {
@@ -47,12 +53,17 @@ var NearSigner = class {
 		return await this.deps.commands.signTransaction(args);
 	}
 	async sendTransaction(rawArgs) {
-		const args = {
+		let subject;
+		try {
+			subject = await this.deps.currentWallet.nearSubject(rawArgs);
+		} catch (error) {
+			return nearTransactionFailure(error, "not_submitted");
+		}
+		return this.deps.commands.sendTransaction({
 			...rawArgs,
-			...await this.deps.currentWallet.nearSubject(rawArgs),
+			...subject,
 			options: rawArgs.options ?? {}
-		};
-		return await this.deps.commands.sendTransaction(args);
+		});
 	}
 	async signDelegateAction(rawArgs) {
 		const args = {

package/dist/esm/SeamsWeb/walletIframe/client/nearCommands.js

@@ -1,4 +1,5 @@
 import { toError } from "../../../shared-ts/src/utils/errors.js";
+import { nearTransactionFailure, notifyNearTransactionResult } from "../../../core/signingEngine/nearTransactionSubmission.js";
 //#region src/SeamsWeb/walletIframe/client/nearCommands.ts
 function createApplicationNearCommands(walletIframe, beforeSigning, transactionDispatch) {
 	const commands = new ApplicationNearCommands(walletIframe, beforeSigning, transactionDispatch);
@@ -31,13 +32,12 @@ var ApplicationNearCommands = class {
 				transaction,
 				options: args.options
 			}, this.transactionDispatch);
-			await args.options?.afterCall?.(true, result);
+			await notifyNearTransactionResult(args.options, result);
 			return result;
 		} catch (error) {
-			const e = toError(error);
-			await args.options?.onError?.(e);
-			await args.options?.afterCall?.(false, void 0, e);
-			throw e;
+			const result = nearTransactionFailure(error, "not_submitted");
+			await notifyNearTransactionResult(args.options, result);
+			return result;
 		}
 	}
 	async signTransaction(args) {
@@ -83,13 +83,12 @@ var ApplicationNearCommands = class {
 					...args.options && "waitUntil" in args.options ? { waitUntil: args.options.waitUntil } : {}
 				}
 			});
-			await args.options?.afterCall?.(true, result);
+			await notifyNearTransactionResult(args.options, result);
 			return result;
 		} catch (error) {
-			const e = toError(error);
-			await args.options?.onError?.(e);
-			await args.options?.afterCall?.(false, void 0, e);
-			throw e;
+			const result = nearTransactionFailure(error, "not_submitted");
+			await notifyNearTransactionResult(args.options, result);
+			return result;
 		}
 	}
 	async signDelegateAction(args) {

package/dist/esm/SeamsWeb/walletIframe/client/router.js

@@ -3,6 +3,7 @@ import { extractBorshBytesFromPlainSignedTx, isBoolean, isObject, isPlainSignedT
 import { parseMpcMaterialActivationRef } from "../../../shared-ts/src/utils/domainIds.js";
 import { createIframePlacementCommands } from "./placementCommands.js";
 import { toError } from "../../../shared-ts/src/utils/errors.js";
+import { NearTransactionRequest, parseNearTransactionResult } from "../../../core/signingEngine/nearTransactionSubmission.js";
 import { secureRandomBase36 } from "../../../shared-ts/src/utils/secureRandomId.js";
 import { SignedTransaction } from "../../../core/rpcClients/near/NearClient.js";
 import { thresholdEcdsaChainTargetsEqual, toWalletId } from "../../../core/signingEngine/interfaces/ecdsaChainTarget.js";
@@ -2463,31 +2464,39 @@ var WalletIframeRouter = class {
 		};
 	}
 	async signAndSendTransaction(payload, transactionDispatch = { kind: "ordinary" }) {
-		if (transactionDispatch.kind === "reviewed") payload = {
-			...payload,
-			options: {
-				...payload.options,
-				confirmationConfig: transactionDispatch.reservation.confirmationConfig
-			}
-		};
-		const { options } = payload;
-		const safeOptions = {
-			waitUntil: options.waitUntil,
-			...options.voiceId !== void 0 ? { voiceId: options.voiceId } : {},
-			confirmationConfig: options.confirmationConfig,
-			...typeof options.signerSlot === "number" ? { signerSlot: options.signerSlot } : {},
-			...options.confirmerText ? { confirmerText: options.confirmerText } : {}
-		};
-		return (await this.post({
-			type: "PM_SIGN_AND_SEND_TX",
-			payload: {
-				walletId: payload.walletId,
-				nearAccountId: payload.nearAccountId,
-				transaction: payload.transaction,
-				options: safeOptions
-			},
-			options: { onProgress: this.wrapOnEvent(options?.onEvent, isSigningFlowEvent) }
-		}, { transactionDispatch })).result;
+		const request = new NearTransactionRequest({ kind: "sign_and_send" });
+		try {
+			if (transactionDispatch.kind === "reviewed") payload = {
+				...payload,
+				options: {
+					...payload.options,
+					confirmationConfig: transactionDispatch.reservation.confirmationConfig
+				}
+			};
+			const { options } = payload;
+			const safeOptions = {
+				waitUntil: options.waitUntil,
+				...options.voiceId !== void 0 ? { voiceId: options.voiceId } : {},
+				confirmationConfig: options.confirmationConfig,
+				...typeof options.signerSlot === "number" ? { signerSlot: options.signerSlot } : {},
+				...options.confirmerText ? { confirmerText: options.confirmerText } : {}
+			};
+			return parseNearTransactionResult((await this.post({
+				type: "PM_SIGN_AND_SEND_TX",
+				payload: {
+					walletId: payload.walletId,
+					nearAccountId: payload.nearAccountId,
+					transaction: payload.transaction,
+					options: safeOptions
+				},
+				options: { onProgress: this.wrapOnEvent(options?.onEvent, isSigningFlowEvent) }
+			}, {
+				transactionDispatch,
+				onDispatched: request.dispatched
+			})).result);
+		} catch (error) {
+			return request.failed(error);
+		}
 	}
 	async hasPasskeyCredential(walletId) {
 		return !!(await this.post({
@@ -2518,18 +2527,26 @@ var WalletIframeRouter = class {
 		})).result);
 	}
 	async sendTransaction(args) {
-		const { options } = args;
-		const safeOptions = options ? { waitUntil: options.waitUntil } : void 0;
-		return (await this.post({
-			type: "PM_SEND_TRANSACTION",
-			payload: {
-				walletId: args.walletId,
-				nearAccountId: args.nearAccountId,
-				signedTransaction: args.signedTransaction,
-				options: safeOptions
-			},
-			options: { onProgress: this.wrapOnEvent(options?.onEvent, isSigningFlowEvent) }
-		})).result;
+		const request = new NearTransactionRequest({
+			kind: "send",
+			transactionId: args.signedTransaction.transactionHash
+		});
+		try {
+			const { options } = args;
+			const safeOptions = options ? { waitUntil: options.waitUntil } : void 0;
+			return parseNearTransactionResult((await this.post({
+				type: "PM_SEND_TRANSACTION",
+				payload: {
+					walletId: args.walletId,
+					nearAccountId: args.nearAccountId,
+					signedTransaction: args.signedTransaction,
+					options: safeOptions
+				},
+				options: { onProgress: this.wrapOnEvent(options?.onEvent, isSigningFlowEvent) }
+			}, { onDispatched: request.dispatched })).result);
+		} catch (error) {
+			return request.failed(error);
+		}
 	}
 	async resolveExactKeyExportLane(input) {
 		return parseResolveExactKeyExportLaneResult((await this.post({
@@ -2711,7 +2728,7 @@ var WalletIframeRouter = class {
 				requestId,
 				payload
 			});
-			if (!this.reviews.has(requestId) && isWalletFlowEvent(payload) && payload.status === "cancelled") {
+			if (!this.reviews.has(requestId) && this.state.pending.get(requestId)?.requestType !== "PM_SIGN_AND_SEND_TX" && this.state.pending.get(requestId)?.requestType !== "PM_SEND_TRANSACTION" && isWalletFlowEvent(payload) && payload.status === "cancelled") {
 				this.settlePendingRequestCancellation(requestId, false);
 				this.sendBestEffortCancel(requestId);
 				return;
@@ -2902,6 +2919,7 @@ var WalletIframeRouter = class {
 						options: void 0
 					};
 					this.state.port.postMessage(serializableFull);
+					postOpts?.onDispatched?.();
 				} catch (err) {
 					this.state.pending.delete(requestId);
 					window.clearTimeout(timer);
@@ -3055,6 +3073,7 @@ function normalizeSignedTransactionResult(result) {
 			transaction: signedTransaction.transaction,
 			signature: signedTransaction.signature,
 			borsh_bytes: extractBorshBytesFromPlainSignedTx(signedTransaction),
+			transactionHash: signedTransaction.transactionHash,
 			...nonceLease ? { nonceLease } : {},
 			...serverDispatch ? { serverDispatch } : {}
 		})

package/dist/esm/SeamsWeb/walletIframe/host/surface-measurement-reporter.js

@@ -23,6 +23,7 @@ function sizeFromEntryOrElement(element, entry) {
 function sizeForReporter(options, entry) {
 	if (options.kind === "request_scroll_surface") {
 		const rect = options.element.getBoundingClientRect();
+		if (options.element.classList.contains("seams-confirm-surface-pinned")) return sizeFromRect(rect);
 		return sizeFromRect({
 			width: Math.max(options.element.scrollWidth, rect.width),
 			height: Math.max(options.element.scrollHeight, rect.height)

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

@@ -753,7 +753,7 @@ var AuthMenuSurface = class extends Component {
 					"data-auth-menu-provider": "google",
 					disabled: !isAuthMenuGoogleActionReady(viewModel),
 					onClick: this.onGoogleClick,
-					children: [googleIcon(), /* @__PURE__ */ jsx("span", { children: /* @__PURE__ */ jsx(WalletText, { copy: viewModel.mode === "login" ? "Email code (Google)" : "Continue with Google" }) })]
+					children: [googleIcon(), /* @__PURE__ */ jsx("span", { children: /* @__PURE__ */ jsx(WalletText, { copy: viewModel.mode === "login" ? "Unlock with email code" : "Continue with Google" }) })]
 				}) : null,
 				viewModel.mode === "login" && viewModel.accountOptions.some(voiceAvailableForWallet.bind(null, selectedLoginAccount(viewModel)?.walletId)) ? /* @__PURE__ */ jsxs("button", {
 					type: "button",

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

@@ -24,6 +24,7 @@ function authMenuStyles(document) {
 var MountedAuthMenuSurface = class {
 	element;
 	styles;
+	entrance = [];
 	state;
 	constructor(input) {
 		const document = input.parent.ownerDocument;
@@ -39,11 +40,36 @@ var MountedAuthMenuSurface = class {
 		input.parent.appendChild(this.element);
 		try {
 			this.update(input.viewModel);
+			this.animateEntrance(input.initialHeightCssPx);
 		} catch (error) {
 			this.dispose();
 			throw error;
 		}
 	}
+	animateEntrance(initialHeightCssPx) {
+		if (initialHeightCssPx === void 0 || window.matchMedia("(prefers-reduced-motion: reduce)").matches) return;
+		const card = this.element.querySelector(".auth-menu-root");
+		if (!card) return;
+		const height = card.getBoundingClientRect().height;
+		this.entrance.push(card.animate([{
+			height: `${initialHeightCssPx}px`,
+			minHeight: "0px",
+			overflow: "hidden"
+		}, {
+			height: `${height}px`,
+			minHeight: "0px",
+			overflow: "hidden"
+		}], {
+			duration: 200,
+			easing: "cubic-bezier(0.32, 0.72, 0, 1)"
+		}));
+		for (const child of card.children) this.entrance.push(child.animate([{ opacity: 0 }, { opacity: 1 }], {
+			duration: 140,
+			delay: 60,
+			fill: "backwards",
+			easing: "cubic-bezier(0.25, 1, 0.5, 1)"
+		}));
+	}
 	update(viewModel) {
 		if (this.state.kind === "disposed") return;
 		this.element.lang = viewModel.appearance.locale ?? "en";
@@ -59,6 +85,8 @@ var MountedAuthMenuSurface = class {
 	dispose() {
 		if (this.state.kind === "disposed") return;
 		this.state = { kind: "disposed" };
+		for (const animation of this.entrance) animation.cancel();
+		this.entrance = [];
 		this.element.removeEventListener("cancel", this.cancel);
 		render(null, this.element);
 		this.styles.deleteDynamicRule(this.element.id + "-appearance");

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

@@ -203,6 +203,7 @@ function parseHostedAuthMenuOpenRequest(value) {
 		"kind",
 		"authMenuSessionId",
 		"initialMode",
+		"initialHeightCssPx",
 		"loginTarget",
 		"registrationAccountInput",
 		"showRegistrationInput",
@@ -212,6 +213,8 @@ function parseHostedAuthMenuOpenRequest(value) {
 	]) || !hasOnlyHostedAuthMenuCopyKeys(record.copy)) return null;
 	const authMenuSessionId = hostedAuthMenuSessionIdFromBoundary(record.authMenuSessionId);
 	const initialMode = parseAuthMenuMode(record.initialMode);
+	const initialHeightCssPx = record.initialHeightCssPx;
+	if (initialHeightCssPx !== void 0 && (typeof initialHeightCssPx !== "number" || !Number.isFinite(initialHeightCssPx) || initialHeightCssPx <= 0)) return null;
 	const loginTargetRecord = recordFromBoundary(record.loginTarget);
 	const loginWalletId = loginTargetRecord?.kind === "wallet" || loginTargetRecord?.kind === "wallet_sync" ? parseWalletId(loginTargetRecord.walletId) : null;
 	const loginTarget = loginTargetRecord?.kind === "discoverable" && hasOnlyKeys(loginTargetRecord, ["kind"]) ? { kind: "discoverable" } : loginTargetRecord?.kind === "wallet" && hasOnlyKeys(loginTargetRecord, ["kind", "walletId"]) && loginWalletId?.ok ? {
@@ -228,6 +231,7 @@ function parseHostedAuthMenuOpenRequest(value) {
 		kind: "hosted_auth_menu_open_v1",
 		authMenuSessionId,
 		initialMode,
+		initialHeightCssPx,
 		loginTarget,
 		registrationAccountInput,
 		showRegistrationInput: record.showRegistrationInput,
@@ -242,6 +246,7 @@ function buildHostedAuthMenuOpenRequest(args) {
 	if (!argsRecord || !hasOnlyKeys(argsRecord, [
 		"authMenuSessionId",
 		"initialMode",
+		"initialHeightCssPx",
 		"loginTarget",
 		"registrationAccountInput",
 		"showRegistrationInput",
@@ -255,6 +260,7 @@ function buildHostedAuthMenuOpenRequest(args) {
 		kind: "hosted_auth_menu_open_v1",
 		authMenuSessionId: parsedSessionId,
 		initialMode: args.initialMode ?? "login",
+		initialHeightCssPx: args.initialHeightCssPx,
 		loginTarget: args.loginTarget ?? { kind: "discoverable" },
 		registrationAccountInput: args.registrationAccountInput ?? "implicit_wallet",
 		showRegistrationInput: args.showRegistrationInput ?? false,

package/dist/esm/core/rpcClients/near/NearClient.js

@@ -1,13 +1,20 @@
+import { requireCanonicalString } from "../../../shared-ts/src/utils/validation.js";
 import { errorMessage } from "../../../shared-ts/src/utils/errors.js";
 import { NearJsonRpcClient, SignedTransaction as SignedTransaction$1 } from "../../../shared-ts/src/near/nearClient.js";
 import { NearRpcError } from "./NearRpcError.js";
 //#region src/core/rpcClients/near/NearClient.ts
 var SignedTransaction = class SignedTransaction extends SignedTransaction$1 {
+	transactionHash;
+	constructor(input) {
+		super(input);
+		this.transactionHash = input.transactionHash;
+	}
 	static fromPlain(input) {
 		return new SignedTransaction({
 			transaction: input.transaction,
 			signature: input.signature,
 			borsh_bytes: input.borsh_bytes,
+			transactionHash: requireCanonicalString(input.transactionHash, "signed transaction hash"),
 			...input.nonceLease ? { nonceLease: input.nonceLease } : {},
 			...input.serverDispatch ? { serverDispatch: input.serverDispatch } : {}
 		});

package/dist/esm/core/signingEngine/flows/signNear/signTransactions.js

@@ -908,12 +908,15 @@ function toSignedTransactionResult(args) {
 	const signedTx = signedTransactions[0];
 	if (!signedTx || !signedTx.transaction || !signedTx.signature) throw new Error("Incomplete signed transaction data received");
 	const nonceLease = args.nonceLeases?.[0];
+	const transactionHash = args.okResponse.payload.transactionHashes?.[0];
+	if (!transactionHash) throw new Error("Signed transaction is missing its hash");
 	const serverDispatch = signedTx.serverDispatch;
 	return {
 		signedTransaction: new SignedTransaction({
 			transaction: signedTx.transaction,
 			signature: signedTx.signature,
 			borsh_bytes: Array.from(signedTx.borshBytes || []),
+			transactionHash,
 			...nonceLease ? { nonceLease } : {},
 			...serverDispatch ? { serverDispatch } : {}
 		}),

package/dist/esm/core/signingEngine/nearTransactionSubmission.js

@@ -0,0 +1,89 @@
+import { requireCanonicalString, requireNonEmptyString, requireRecord } from "../../shared-ts/src/utils/validation.js";
+import { safeErrorMessage } from "../../shared-ts/src/utils/errors.js";
+import { decodeNearFinalExecutionOutcome } from "../../shared-ts/src/utils/nearRpcResults.js";
+//#region src/core/signingEngine/nearTransactionSubmission.ts
+var NearTransactionRequest = class {
+	state = "not_dispatched";
+	constructor(transaction) {
+		this.transaction = transaction;
+	}
+	dispatched = () => {
+		this.state = "dispatched";
+	};
+	failed(error) {
+		if (this.state === "not_dispatched") return nearTransactionFailure(error, "not_submitted");
+		switch (this.transaction.kind) {
+			case "sign_and_send": return nearTransactionFailure(error, "submission_unknown");
+			case "send": return unresolvedNearTransaction(this.transaction.transactionId, error);
+			default: return assertNeverNearTransactionState(this.transaction);
+		}
+	}
+};
+function assertNeverNearTransactionState(value) {
+	throw new Error(`Unsupported NEAR transaction state: ${String(value)}`);
+}
+function parseNearTransactionResult(raw) {
+	const result = requireRecord(raw, "NEAR transaction result");
+	if (result.success === true) {
+		const transactionId = requireCanonicalString(result.transactionId, "transactionId");
+		const outcome = decodeNearFinalExecutionOutcome(result.result);
+		if (transactionId !== outcome.transaction.hash) throw new Error("NEAR transaction result contains different transaction hashes");
+		if (typeof outcome.status === "object" && "Failure" in outcome.status) return unresolvedNearTransaction(transactionId, /* @__PURE__ */ new Error("NEAR transaction execution failed"));
+		return {
+			success: true,
+			transactionId,
+			result: outcome
+		};
+	}
+	if (result.success !== false) throw new Error("Invalid NEAR transaction result");
+	const error = requireNonEmptyString(result.error, "NEAR transaction error");
+	switch (result.kind) {
+		case "not_submitted": return {
+			success: false,
+			kind: "not_submitted",
+			error
+		};
+		case "submission_unknown": return {
+			success: false,
+			kind: "submission_unknown",
+			error
+		};
+		case "unresolved": return {
+			success: false,
+			kind: "unresolved",
+			transactionId: requireCanonicalString(result.transactionId, "transactionId"),
+			error
+		};
+		default: throw new Error("Invalid NEAR transaction failure");
+	}
+}
+function nearTransactionFailure(error, fallback) {
+	return {
+		success: false,
+		kind: fallback,
+		error: safeErrorMessage(error) || "NEAR transaction failed"
+	};
+}
+function unresolvedNearTransaction(transactionId, error) {
+	return {
+		success: false,
+		kind: "unresolved",
+		transactionId,
+		error: safeErrorMessage(error)
+	};
+}
+/** Application hooks cannot replace a settled transaction outcome with their own error. */
+async function notifyNearTransactionResult(options, result) {
+	const error = result.success ? void 0 : new Error(result.error);
+	if (error) try {
+		await options?.onError?.(error);
+	} catch {}
+	try {
+		if (result.success) await options?.afterCall?.(true, result);
+		else await options?.afterCall?.(false, void 0, error);
+	} catch {}
+}
+//#endregion
+export { NearTransactionRequest, nearTransactionFailure, notifyNearTransactionResult, parseNearTransactionResult };
+
+//# sourceMappingURL=nearTransactionSubmission.js.map

package/dist/esm/core/signingEngine/uiConfirm/ui/confirm-surface-resize.js

@@ -299,7 +299,7 @@ function attachConfirmSurfaceResizeChoreographer(element, options = {}) {
 			current.moved = true;
 		} else current.framesSinceChange += 1;
 		const progress = clamp((viewportPx - current.originHostPx) / current.deltaCssPx, 0, 1);
-		if (progress >= 1) {
+		if (viewportPx === Math.round(current.originHostPx + current.deltaCssPx)) {
 			current.framesAtTarget += 1;
 			if (current.sawIntermediate || current.framesAtTarget >= LANDING_CONFIRM_FRAMES) {
 				settle();
@@ -310,7 +310,7 @@ function attachConfirmSurfaceResizeChoreographer(element, options = {}) {
 		}
 		if (current.framesAtTarget > 0) surfaceMotionDiagnostics.blipFrames += 1;
 		current.framesAtTarget = 0;
-		if (progress > 0) current.sawIntermediate = true;
+		if (progress > 0 && progress < 1) current.sawIntermediate = true;
 		current.driver.setProgress(progress);
 		const settledFrames = current.moved ? SETTLED_FRAMES_AFTER_MOTION : SETTLED_FRAMES_WITHOUT_MOTION;
 		if (current.framesSinceChange >= settledFrames) {

package/dist/esm/core/signingEngine/uiConfirm/ui/preact/ReviewDisclosure.js

@@ -69,8 +69,14 @@ var ReviewDisclosure = class extends Component {
 			return;
 		}
 		details.open = true;
+		const scrollArea = details.parentElement?.closest(".seams-review-technical > div");
+		if (scrollArea && scrollArea.scrollHeight > scrollArea.clientHeight) {
+			details.open = opening;
+			details.removeAttribute("data-closing");
+			return;
+		}
 		details.setAttribute("data-resizing", "");
-		const target = opening ? body.scrollHeight : 0;
+		const target = opening ? body.getBoundingClientRect().height : 0;
 		this.motion = {
 			kind: "hosted",
 			opening