@seams/wallet 0.8.0 → 0.9.1

package/dist/esm/core/signingEngine/workerManager/workerTransport.js

@@ -1,734 +0,0 @@
-import { isObject } from "../../../shared-ts/src/utils/validation.js";
-import { secureRandomId } from "../../../shared-ts/src/utils/secureRandomId.js";
-import { EcdsaDerivationClientCustomRequestType, EcdsaPresignClientRequestType, SignerWorkerOperationError, WorkerControlMessage } from "./workerTypes.js";
-import { errorMessage } from "../../../shared-ts/src/utils/errors.js";
-import { clearAllRouterAbEcdsaDerivationClientPresignatures, clearRouterAbEcdsaDerivationClientPresignaturesForWallet } from "../routerAb/ecdsaDerivation/presignaturePool.js";
-import { resolveWorkerUrl } from "../../walletRuntimePaths/workers.js";
-import { dropUnlockedWalletEd25519ExportRootCapabilityReferenceV1 } from "../walletCustody/unlockedEd25519ExportRootCapability.js";
-import { SIGNER_WORKER_MANAGER_CONFIG } from "../../../config.js";
-import { resolveMultichainWorkerUrl } from "../../walletRuntimePaths/multichainWorkers.js";
-import { resolveEmailOtpWorkerUrl } from "../../walletRuntimePaths/emailOtpWorker.js";
-import { resolveWalletCustodyCeremonyWorkerUrl } from "../../walletRuntimePaths/walletCustodyCeremonyWorker.js";
-import { EcdsaClientWorkerControlKind } from "./ecdsaClientWorkerChannels.js";
-//#region src/core/signingEngine/workerManager/workerTransport.ts
-function roundWorkerDurationMs(startedAt) {
-	return Math.max(0, Math.round(performance.now() - startedAt));
-}
-function assertNeverWorkerPrewarmResult(value) {
-	throw new Error(`Unsupported Email OTP Yao prewarm result: ${String(value)}`);
-}
-function assertNeverWorkerPrewarmRequest(value) {
-	throw new Error(`Unsupported Email OTP Yao prewarm request: ${String(value)}`);
-}
-const SIGNER_WORKER_KINDS = [
-	"nearSigner",
-	"ecdsaDerivationClient",
-	"ecdsaPresignClient",
-	"ecdsaOnlineClient",
-	"evmCrypto",
-	"tempoSigner",
-	"emailOtp",
-	"walletCustodyCeremony"
-];
-const MULTICHAIN_WORKER_DEFAULT_TIMEOUT_MS = 2e4;
-/**
-* A timed-out operation resets its worker, and resetting a presign or
-* derivation worker discards the state other ceremonies hold in it. Name the
-* operation that caused the reset.
-*/
-function warnWorkerOperationTimedOut(kind, type, timeoutMs) {
-	console.warn("[WorkerTransport] operation timed out; resetting worker", {
-		kind,
-		type: String(type),
-		timeoutMs
-	});
-}
-function makeId(prefix) {
-	return secureRandomId(prefix, 32, "signer worker request IDs");
-}
-function isReadyFrame(value) {
-	return value?.type === WorkerControlMessage.WORKER_READY || value?.ready === true;
-}
-function isWasmPrewarmWorkerKind(kind) {
-	return kind === "nearSigner" || kind === "ecdsaDerivationClient" || kind === "evmCrypto" || kind === "tempoSigner";
-}
-function createWorkerReadiness() {
-	let resolvePromise = () => {};
-	let rejectPromise = () => {};
-	const promise = new Promise((resolve, reject) => {
-		resolvePromise = resolve;
-		rejectPromise = reject;
-	});
-	promise.catch(() => {});
-	return {
-		promise,
-		resolve: resolvePromise,
-		reject: rejectPromise,
-		settled: false
-	};
-}
-function resolveWorkerReadiness(readiness) {
-	if (readiness.settled) return;
-	readiness.settled = true;
-	readiness.resolve();
-}
-function rejectWorkerReadiness(readiness, error) {
-	if (readiness.settled) return;
-	readiness.settled = true;
-	readiness.reject(error);
-}
-function isNearRpcProgressFrame(value) {
-	return !!value && typeof value === "object" && typeof value.id === "string" && value.progress === true;
-}
-function isNearRpcSuccessFrame(value) {
-	return !!value && typeof value === "object" && typeof value.id === "string" && value.ok === true && "result" in value;
-}
-function isNearRpcErrorFrame(value) {
-	return !!value && typeof value === "object" && typeof value.id === "string" && value.ok === false && typeof value.error === "string";
-}
-function isRpcSuccessFrame(value) {
-	return !!value && typeof value === "object" && typeof value.id === "string" && value.ok === true && "result" in value;
-}
-function isRpcErrorFrame(value) {
-	return !!value && typeof value === "object" && typeof value.id === "string" && value.ok === false && typeof value.error === "string";
-}
-function isRpcProgressFrame(value) {
-	return !!value && typeof value === "object" && typeof value.id === "string" && value.progress === true && "payload" in value;
-}
-var WorkerTransport = class {
-	constructor() {
-		this.workers = /* @__PURE__ */ new Map();
-		this.workerReadiness = /* @__PURE__ */ new Map();
-		this.pendingByKind = /* @__PURE__ */ new Map();
-		this.messageHandlers = /* @__PURE__ */ new Map();
-		this.errorHandlers = /* @__PURE__ */ new Map();
-		this.presignAuthorityKind = null;
-		this.presignOnlineConnected = false;
-		this.ecdsaRegistrationCryptoPrewarmPromise = null;
-		this.emailOtpYaoPrewarmPromise = null;
-	}
-	setWorkerBaseOrigin(origin) {
-		if (this.workerBaseOrigin === origin) return;
-		this.workerBaseOrigin = origin;
-		this.emailOtpYaoPrewarmPromise = null;
-		for (const kind of Array.from(this.workers.keys())) this.resetWorker(kind);
-	}
-	async prewarmWorkers() {
-		for (const kind of SIGNER_WORKER_KINDS) this.getOrCreateWorker(kind);
-		await Promise.all([
-			this.requireWorkerReadiness("nearSigner"),
-			this.requireWorkerReadiness("ecdsaDerivationClient"),
-			this.requireWorkerReadiness("evmCrypto"),
-			this.requireWorkerReadiness("tempoSigner")
-		]);
-	}
-	async clearEcdsaClientWorkerState(target) {
-		switch (target.kind) {
-			case "all":
-				this.resetWorker("ecdsaPresignClient");
-				return;
-			case "wallet":
-				clearRouterAbEcdsaDerivationClientPresignaturesForWallet(target.walletId);
-				if (!this.workers.has("ecdsaPresignClient")) return;
-				await this.requestOperation({
-					kind: "ecdsaPresignClient",
-					request: {
-						type: EcdsaPresignClientRequestType.ClearWallet,
-						timeoutMs: 2e4,
-						payload: { walletId: target.walletId }
-					}
-				});
-				return;
-		}
-	}
-	requireWorkerReadiness(kind) {
-		const readiness = this.workerReadiness.get(kind);
-		if (!readiness) throw new Error(`${kind} worker readiness was not initialized`);
-		return readiness.promise;
-	}
-	/**
-	* Initializes the ECDSA derivation and registration WASM inside the
-	* derivation worker during the authentication prompt, so the first ceremony
-	* call after auth does not pay module init (measured 654 ms cold vs 88 ms
-	* warm on `ecdsaRegistrationClientCreateMs`). Fire-and-forget safe: failure
-	* leaves the lazy init path exactly as it was.
-	*/
-	async prewarmEcdsaRegistrationCrypto() {
-		const existing = this.ecdsaRegistrationCryptoPrewarmPromise;
-		if (existing) return await existing;
-		const prewarmPromise = this.requestEcdsaRegistrationCryptoPrewarm();
-		this.ecdsaRegistrationCryptoPrewarmPromise = prewarmPromise;
-		const outcome = await prewarmPromise;
-		if (outcome.kind === "failed" && this.ecdsaRegistrationCryptoPrewarmPromise === prewarmPromise) this.ecdsaRegistrationCryptoPrewarmPromise = null;
-		return outcome;
-	}
-	async requestEcdsaRegistrationCryptoPrewarm() {
-		const startedAt = performance.now();
-		try {
-			await this.requestDerivationOperation({
-				type: EcdsaDerivationClientCustomRequestType.PrewarmEcdsaRegistrationCrypto,
-				payload: {}
-			});
-			return {
-				kind: "succeeded",
-				wasmInitMs: roundWorkerDurationMs(startedAt)
-			};
-		} catch {
-			return {
-				kind: "failed",
-				wasmInitMs: roundWorkerDurationMs(startedAt)
-			};
-		}
-	}
-	async prewarmEmailOtpYao(request = { kind: "requested" }) {
-		switch (request.kind) {
-			case "not_requested": return {
-				kind: "not_requested",
-				elapsedMs: 0,
-				workerPrewarmMs: 0,
-				yaoWasmInitMs: 0
-			};
-			case "requested": break;
-			default: return assertNeverWorkerPrewarmRequest(request);
-		}
-		const existing = this.emailOtpYaoPrewarmPromise;
-		if (existing) return await existing;
-		const prewarmPromise = this.requestEmailOtpYaoPrewarm();
-		this.emailOtpYaoPrewarmPromise = prewarmPromise;
-		const outcome = await prewarmPromise;
-		if (outcome.kind === "failed" && this.emailOtpYaoPrewarmPromise === prewarmPromise) this.emailOtpYaoPrewarmPromise = null;
-		return outcome;
-	}
-	async requestEmailOtpYaoPrewarm() {
-		const startedAt = performance.now();
-		try {
-			const result = await this.requestOperation({
-				kind: "emailOtp",
-				request: {
-					type: "prewarmEmailOtpRegistrationCrypto",
-					payload: {}
-				}
-			});
-			const workerPrewarmMs = roundWorkerDurationMs(startedAt);
-			switch (result.kind) {
-				case "succeeded": return {
-					kind: "succeeded",
-					elapsedMs: workerPrewarmMs,
-					workerPrewarmMs,
-					yaoWasmInitMs: result.elapsedMs
-				};
-				case "failed": return {
-					kind: "failed",
-					elapsedMs: workerPrewarmMs,
-					workerPrewarmMs,
-					yaoWasmInitMs: result.elapsedMs,
-					failureStage: result.failureStage
-				};
-				default: return assertNeverWorkerPrewarmResult(result);
-			}
-		} catch {
-			const workerPrewarmMs = roundWorkerDurationMs(startedAt);
-			return {
-				kind: "failed",
-				elapsedMs: workerPrewarmMs,
-				workerPrewarmMs,
-				yaoWasmInitMs: 0,
-				failureStage: "worker_ready"
-			};
-		}
-	}
-	async requestOperation(args) {
-		if (args.kind === "nearSigner") return await this.requestNearOperation(args.request);
-		if (args.kind === "ecdsaDerivationClient") return await this.requestDerivationOperation(args.request);
-		if (args.kind === "ecdsaPresignClient") {
-			this.connectPresignAuthorityChannel(args.request);
-			return await this.requestRpcOperation("ecdsaPresignClient", args.request);
-		}
-		if (args.kind === "ecdsaOnlineClient") {
-			this.connectPresignOnlineChannel();
-			return await this.requestRpcOperation("ecdsaOnlineClient", args.request);
-		}
-		if (args.kind === "evmCrypto") return await this.requestRpcOperation("evmCrypto", args.request);
-		if (args.kind === "tempoSigner") return await this.requestRpcOperation("tempoSigner", args.request);
-		if (args.kind === "walletCustodyCeremony") return await this.requestRpcOperation("walletCustodyCeremony", args.request);
-		return await this.requestRpcOperation(args.kind, args.request);
-	}
-	async requestNearOperation({ type, payload, onEvent, timeoutMs = SIGNER_WORKER_MANAGER_CONFIG.TIMEOUTS.DEFAULT, transfer }) {
-		const worker = this.getOrCreateWorker("nearSigner");
-		const requestId = makeId("nearSigner");
-		return await new Promise((resolve, reject) => {
-			const timeoutId = setTimeout(() => {
-				this.rejectRequest("nearSigner", requestId, new SignerWorkerOperationError({
-					message: `Worker operation timed out after ${timeoutMs}ms`,
-					code: "TIMEOUT",
-					workerKind: "nearSigner"
-				}));
-				warnWorkerOperationTimedOut("nearSigner", type, timeoutMs);
-				this.resetWorker("nearSigner");
-				try {
-					const seconds = Math.round(timeoutMs / 1e3);
-					window.postMessage({
-						type: "MODAL_TIMEOUT",
-						payload: `Timed out after ${seconds}s, try again`
-					}, "*");
-				} catch {}
-			}, timeoutMs);
-			this.getPendingMap("nearSigner").set(requestId, {
-				resolve: (value) => resolve(value),
-				reject,
-				onEvent: onEvent ? (update) => onEvent(update) : void 0,
-				timeoutId
-			});
-			try {
-				worker.postMessage({
-					id: requestId,
-					type,
-					payload
-				}, transfer || []);
-			} catch (error) {
-				this.rejectRequest("nearSigner", requestId, new SignerWorkerOperationError({
-					message: `[nearSigner] failed to postMessage: ${errorMessage(error)}`,
-					code: "WORKER_POSTMESSAGE_ERROR",
-					workerKind: "nearSigner"
-				}));
-			}
-		});
-	}
-	async requestDerivationOperation({ type, payload, timeoutMs = SIGNER_WORKER_MANAGER_CONFIG.TIMEOUTS.DEFAULT, transfer }) {
-		const worker = this.getOrCreateWorker("ecdsaDerivationClient");
-		const requestId = makeId("ecdsaDerivationClient");
-		return await new Promise((resolve, reject) => {
-			const timeoutId = setTimeout(() => {
-				this.rejectRequest("ecdsaDerivationClient", requestId, new SignerWorkerOperationError({
-					message: `Worker operation timed out after ${timeoutMs}ms`,
-					code: "TIMEOUT",
-					workerKind: "ecdsaDerivationClient"
-				}));
-				warnWorkerOperationTimedOut("ecdsaDerivationClient", type, timeoutMs);
-				this.resetWorker("ecdsaDerivationClient");
-			}, timeoutMs);
-			this.getPendingMap("ecdsaDerivationClient").set(requestId, {
-				resolve: (value) => resolve(value),
-				reject,
-				timeoutId
-			});
-			try {
-				worker.postMessage({
-					id: requestId,
-					type,
-					payload
-				}, transfer || []);
-			} catch (error) {
-				this.rejectRequest("ecdsaDerivationClient", requestId, new SignerWorkerOperationError({
-					message: `[ecdsaDerivationClient] failed to postMessage: ${errorMessage(error)}`,
-					code: "WORKER_POSTMESSAGE_ERROR",
-					workerKind: "ecdsaDerivationClient"
-				}));
-			}
-		});
-	}
-	async requestRpcOperation(kind, request) {
-		const worker = this.getOrCreateWorker(kind);
-		const requestId = makeId(kind);
-		const parsedTimeoutMs = Math.floor(Number(request.timeoutMs));
-		const timeoutMs = Number.isFinite(parsedTimeoutMs) && parsedTimeoutMs > 0 ? parsedTimeoutMs : MULTICHAIN_WORKER_DEFAULT_TIMEOUT_MS;
-		return await new Promise((resolve, reject) => {
-			const timeoutId = setTimeout(() => {
-				this.rejectRequest(kind, requestId, new SignerWorkerOperationError({
-					message: `Worker operation timed out after ${timeoutMs}ms`,
-					code: "TIMEOUT",
-					workerKind: kind
-				}));
-				warnWorkerOperationTimedOut(kind, request.type, timeoutMs);
-				this.resetWorker(kind);
-			}, timeoutMs);
-			this.getPendingMap(kind).set(requestId, {
-				resolve: (value) => resolve(value),
-				reject,
-				onEvent: request.onEvent,
-				timeoutId
-			});
-			try {
-				worker.postMessage({
-					id: requestId,
-					type: request.type,
-					payload: request.payload
-				}, request.transfer || []);
-			} catch (error) {
-				this.rejectRequest(kind, requestId, new SignerWorkerOperationError({
-					message: `[${kind}] failed to postMessage: ${errorMessage(error)}`,
-					code: "WORKER_POSTMESSAGE_ERROR",
-					workerKind: kind
-				}));
-			}
-		});
-	}
-	getOrCreateWorker(kind) {
-		const existing = this.workers.get(kind);
-		if (existing) return existing;
-		const worker = this.createWorker(kind);
-		if (isWasmPrewarmWorkerKind(kind)) this.workerReadiness.set(kind, createWorkerReadiness());
-		const messageHandler = (event) => {
-			this.handleWorkerMessage(kind, event);
-		};
-		const errorHandler = (event) => {
-			this.handleWorkerError(kind, event);
-		};
-		worker.addEventListener("message", messageHandler);
-		worker.addEventListener("error", errorHandler);
-		this.workers.set(kind, worker);
-		this.messageHandlers.set(kind, messageHandler);
-		this.errorHandlers.set(kind, errorHandler);
-		return worker;
-	}
-	connectPresignAuthorityChannel(request) {
-		if (request.type !== EcdsaPresignClientRequestType.ListAvailable && request.type !== EcdsaPresignClientRequestType.SessionInit) return;
-		const presignWorker = this.getOrCreateWorker("ecdsaPresignClient");
-		const authorityKind = this.parsePresignAuthorityKind(request.payload);
-		switch (authorityKind) {
-			case "role_local_derivation_handle":
-				this.connectDerivationPresignChannel(presignWorker, authorityKind);
-				return;
-			case "linked_holder_signing_material":
-				this.connectDerivationPresignChannel(presignWorker, authorityKind);
-				return;
-			default:
-		}
-	}
-	parsePresignAuthorityKind(payload) {
-		if (!isObject(payload) || !isObject(payload.authority)) throw new Error("ECDSA presign init authority is required");
-		switch (payload.authority.kind) {
-			case "role_local_derivation_handle":
-			case "linked_holder_signing_material": return payload.authority.kind;
-			default: throw new Error("ECDSA presign init authority kind is invalid");
-		}
-	}
-	createLinkedHolderPresignAuthorityPortV1() {
-		const presignWorker = this.getOrCreateWorker("ecdsaPresignClient");
-		clearAllRouterAbEcdsaDerivationClientPresignatures();
-		const channel = new MessageChannel();
-		presignWorker.postMessage({
-			kind: EcdsaClientWorkerControlKind.AttachLinkedHolderToPresign,
-			port: channel.port1
-		}, [channel.port1]);
-		return channel.port2;
-	}
-	connectDerivationPresignChannel(presignWorker, authorityKind) {
-		if (this.presignAuthorityKind === authorityKind) return;
-		if (this.presignAuthorityKind !== null) clearAllRouterAbEcdsaDerivationClientPresignatures();
-		const derivationWorker = this.getOrCreateWorker("ecdsaDerivationClient");
-		const channel = new MessageChannel();
-		const controlKind = authorityKind === "role_local_derivation_handle" ? EcdsaClientWorkerControlKind.AttachDerivationToPresign : EcdsaClientWorkerControlKind.AttachLinkedHolderToPresign;
-		derivationWorker.postMessage({
-			kind: controlKind,
-			port: channel.port1
-		}, [channel.port1]);
-		presignWorker.postMessage({
-			kind: controlKind,
-			port: channel.port2
-		}, [channel.port2]);
-		this.presignAuthorityKind = authorityKind;
-	}
-	connectPresignOnlineChannel() {
-		if (this.presignOnlineConnected) return;
-		const presignWorker = this.getOrCreateWorker("ecdsaPresignClient");
-		const onlineWorker = this.getOrCreateWorker("ecdsaOnlineClient");
-		const channel = new MessageChannel();
-		presignWorker.postMessage({
-			kind: EcdsaClientWorkerControlKind.AttachPresignToOnline,
-			port: channel.port1
-		}, [channel.port1]);
-		onlineWorker.postMessage({
-			kind: EcdsaClientWorkerControlKind.AttachPresignToOnline,
-			port: channel.port2
-		}, [channel.port2]);
-		this.presignOnlineConnected = true;
-	}
-	createWorker(kind) {
-		try {
-			if (kind === "nearSigner") {
-				const workerUrl = resolveWorkerUrl(SIGNER_WORKER_MANAGER_CONFIG.WORKER.URL, {
-					worker: "signer",
-					baseOrigin: this.workerBaseOrigin
-				});
-				return new Worker(workerUrl, {
-					type: SIGNER_WORKER_MANAGER_CONFIG.WORKER.TYPE,
-					name: SIGNER_WORKER_MANAGER_CONFIG.WORKER.NAME
-				});
-			}
-			if (kind === "ecdsaDerivationClient") {
-				const workerUrl = resolveWorkerUrl(SIGNER_WORKER_MANAGER_CONFIG.ECDSA_DERIVATION_CLIENT_WORKER.URL, {
-					worker: "ecdsaDerivationClient",
-					baseOrigin: this.workerBaseOrigin
-				});
-				return new Worker(workerUrl, {
-					type: SIGNER_WORKER_MANAGER_CONFIG.ECDSA_DERIVATION_CLIENT_WORKER.TYPE,
-					name: SIGNER_WORKER_MANAGER_CONFIG.ECDSA_DERIVATION_CLIENT_WORKER.NAME
-				});
-			}
-			if (kind === "ecdsaPresignClient") {
-				const workerUrl = resolveWorkerUrl(SIGNER_WORKER_MANAGER_CONFIG.ECDSA_PRESIGN_CLIENT_WORKER.URL, {
-					worker: "ecdsaPresignClient",
-					baseOrigin: this.workerBaseOrigin
-				});
-				return new Worker(workerUrl, {
-					type: SIGNER_WORKER_MANAGER_CONFIG.ECDSA_PRESIGN_CLIENT_WORKER.TYPE,
-					name: SIGNER_WORKER_MANAGER_CONFIG.ECDSA_PRESIGN_CLIENT_WORKER.NAME
-				});
-			}
-			if (kind === "ecdsaOnlineClient") {
-				const workerUrl = resolveWorkerUrl(SIGNER_WORKER_MANAGER_CONFIG.ECDSA_ONLINE_CLIENT_WORKER.URL, {
-					worker: "ecdsaOnlineClient",
-					baseOrigin: this.workerBaseOrigin
-				});
-				return new Worker(workerUrl, {
-					type: SIGNER_WORKER_MANAGER_CONFIG.ECDSA_ONLINE_CLIENT_WORKER.TYPE,
-					name: SIGNER_WORKER_MANAGER_CONFIG.ECDSA_ONLINE_CLIENT_WORKER.NAME
-				});
-			}
-			if (kind === "emailOtp") {
-				const workerUrl = resolveEmailOtpWorkerUrl({ baseOrigin: this.workerBaseOrigin });
-				return new Worker(workerUrl, {
-					type: "module",
-					name: "email-otp-worker"
-				});
-			}
-			if (kind === "walletCustodyCeremony") {
-				const workerUrl = resolveWalletCustodyCeremonyWorkerUrl({ baseOrigin: this.workerBaseOrigin });
-				return new Worker(workerUrl, {
-					type: "module",
-					name: "wallet-custody-ceremony-worker"
-				});
-			}
-			const workerUrl = resolveMultichainWorkerUrl(kind, { baseOrigin: this.workerBaseOrigin });
-			return new Worker(workerUrl, {
-				type: "module",
-				name: `${kind}-worker`
-			});
-		} catch (error) {
-			const msg = error instanceof Error ? error.message : String(error);
-			throw new Error(`Failed to create ${kind} worker: ${msg}`);
-		}
-	}
-	handleWorkerMessage(kind, event) {
-		const data = event.data;
-		if (isReadyFrame(data)) {
-			if (isWasmPrewarmWorkerKind(kind)) {
-				const readiness = this.workerReadiness.get(kind);
-				if (readiness) resolveWorkerReadiness(readiness);
-			}
-			return;
-		}
-		if (kind === "nearSigner") {
-			this.handleNearWorkerMessage(data);
-			return;
-		}
-		if (kind === "ecdsaDerivationClient") {
-			this.handleEcdsaDerivationWorkerMessage(data);
-			return;
-		}
-		if (isRpcProgressFrame(data)) {
-			const pending = this.getPendingMap(kind).get(data.id);
-			if (!pending) return;
-			pending.onEvent?.(data.payload);
-			return;
-		}
-		if (isRpcSuccessFrame(data)) {
-			this.resolveRequest(kind, data.id, data.result);
-			return;
-		}
-		if (isRpcErrorFrame(data)) {
-			this.rejectRequest(kind, data.id, new SignerWorkerOperationError({
-				message: data.error || `[${kind}] worker error`,
-				code: data.code,
-				coreCode: data.coreCode,
-				workerKind: kind
-			}));
-			return;
-		}
-		const requestId = isObject(data) && typeof data.id === "string" ? data.id : void 0;
-		if (requestId && this.getPendingMap(kind).has(requestId)) {
-			this.rejectRequest(kind, requestId, new SignerWorkerOperationError({
-				message: `Malformed worker response frame for request ${requestId}`,
-				code: "WORKER_PROTOCOL_ERROR",
-				workerKind: kind
-			}));
-			return;
-		}
-		if (this.getPendingMap(kind).size === 0) return;
-		this.rejectAllPending(kind, new SignerWorkerOperationError({
-			message: `Unknown worker response frame: ${JSON.stringify(data)}`,
-			code: "WORKER_PROTOCOL_ERROR",
-			workerKind: kind
-		}));
-		this.resetWorker(kind);
-	}
-	handleNearWorkerMessage(data) {
-		if (isNearRpcProgressFrame(data)) {
-			const pending = this.getPendingMap("nearSigner").get(data.id);
-			if (!pending) return;
-			pending.onEvent?.(data.payload);
-			return;
-		}
-		if (isNearRpcSuccessFrame(data)) {
-			this.resolveNearResponse(data.id, data.result);
-			return;
-		}
-		if (isNearRpcErrorFrame(data)) {
-			this.rejectRequest("nearSigner", data.id, new SignerWorkerOperationError({
-				message: data.error,
-				code: data.code,
-				coreCode: data.coreCode,
-				workerKind: "nearSigner"
-			}));
-			return;
-		}
-		const requestId = isObject(data) && typeof data.id === "string" ? data.id : void 0;
-		if (requestId && this.getPendingMap("nearSigner").has(requestId)) {
-			this.rejectRequest("nearSigner", requestId, new SignerWorkerOperationError({
-				message: `Malformed worker response frame for request ${requestId}`,
-				code: "WORKER_PROTOCOL_ERROR",
-				workerKind: "nearSigner"
-			}));
-			return;
-		}
-		if (this.getPendingMap("nearSigner").size === 0) return;
-		this.rejectAllPending("nearSigner", new SignerWorkerOperationError({
-			message: `Unknown worker response frame: ${JSON.stringify(data)}`,
-			code: "WORKER_PROTOCOL_ERROR",
-			workerKind: "nearSigner"
-		}));
-		this.resetWorker("nearSigner");
-	}
-	handleEcdsaDerivationWorkerMessage(data) {
-		if (isRpcSuccessFrame(data)) {
-			this.resolveRequest("ecdsaDerivationClient", data.id, data.result);
-			return;
-		}
-		if (isRpcErrorFrame(data)) {
-			this.rejectRequest("ecdsaDerivationClient", data.id, new SignerWorkerOperationError({
-				message: data.error || "[ecdsaDerivationClient] worker error",
-				code: data.code,
-				coreCode: data.coreCode,
-				workerKind: "ecdsaDerivationClient"
-			}));
-			return;
-		}
-		const requestId = isObject(data) && typeof data.id === "string" ? data.id : void 0;
-		if (requestId && this.getPendingMap("ecdsaDerivationClient").has(requestId)) {
-			this.rejectRequest("ecdsaDerivationClient", requestId, new SignerWorkerOperationError({
-				message: `Malformed worker response frame for request ${requestId}`,
-				code: "WORKER_PROTOCOL_ERROR",
-				workerKind: "ecdsaDerivationClient"
-			}));
-			return;
-		}
-		if (this.getPendingMap("ecdsaDerivationClient").size === 0) return;
-		this.rejectAllPending("ecdsaDerivationClient", new SignerWorkerOperationError({
-			message: `Unknown worker response frame: ${JSON.stringify(data)}`,
-			code: "WORKER_PROTOCOL_ERROR",
-			workerKind: "ecdsaDerivationClient"
-		}));
-		this.resetWorker("ecdsaDerivationClient");
-	}
-	resolveNearResponse(requestId, response) {
-		if (!this.getPendingMap("nearSigner").get(requestId)) return;
-		this.resolveRequest("nearSigner", requestId, response);
-	}
-	handleWorkerError(kind, event) {
-		const runtimeError = new SignerWorkerOperationError({
-			message: `[${kind}] worker runtime error: ${event.message || "unknown error"}`,
-			code: "WORKER_RUNTIME_ERROR",
-			workerKind: kind
-		});
-		if (isWasmPrewarmWorkerKind(kind)) {
-			const readiness = this.workerReadiness.get(kind);
-			if (readiness) rejectWorkerReadiness(readiness, runtimeError);
-		}
-		this.rejectAllPending(kind, runtimeError);
-		this.resetWorker(kind);
-	}
-	getPendingMap(kind) {
-		const existing = this.pendingByKind.get(kind);
-		if (existing) return existing;
-		const next = /* @__PURE__ */ new Map();
-		this.pendingByKind.set(kind, next);
-		return next;
-	}
-	resolveRequest(kind, requestId, value) {
-		const pending = this.getPendingMap(kind).get(requestId);
-		if (!pending) return;
-		this.clearRequest(kind, requestId);
-		pending.resolve(value);
-	}
-	rejectRequest(kind, requestId, error) {
-		const pending = this.getPendingMap(kind).get(requestId);
-		if (!pending) return;
-		this.clearRequest(kind, requestId);
-		pending.reject(error);
-	}
-	rejectAllPending(kind, error) {
-		const requestIds = Array.from(this.getPendingMap(kind).keys());
-		for (const requestId of requestIds) this.rejectRequest(kind, requestId, error);
-	}
-	clearRequest(kind, requestId) {
-		const pending = this.getPendingMap(kind).get(requestId);
-		if (!pending) return;
-		if (pending.timeoutId) clearTimeout(pending.timeoutId);
-		this.getPendingMap(kind).delete(requestId);
-	}
-	resetWorker(kind) {
-		if (kind === "ecdsaDerivationClient") {
-			this.presignAuthorityKind = null;
-			this.resetWorker("ecdsaPresignClient");
-		} else if (kind === "ecdsaPresignClient") {
-			this.presignAuthorityKind = null;
-			this.presignOnlineConnected = false;
-			this.resetWorker("ecdsaOnlineClient");
-			this.terminateWorkerOnly("ecdsaDerivationClient");
-		} else if (kind === "ecdsaOnlineClient") this.presignOnlineConnected = false;
-		if (kind === "ecdsaDerivationClient" || kind === "ecdsaPresignClient" || kind === "ecdsaOnlineClient") clearAllRouterAbEcdsaDerivationClientPresignatures();
-		this.terminateWorkerOnly(kind);
-	}
-	terminateWorkerOnly(kind) {
-		const worker = this.workers.get(kind);
-		const readiness = this.readinessForWorker(kind);
-		if (!worker) {
-			if (readiness) {
-				rejectWorkerReadiness(readiness, /* @__PURE__ */ new Error(`${kind} worker was reset`));
-				this.deleteWorkerReadiness(kind);
-			}
-			return;
-		}
-		this.rejectAllPending(kind, /* @__PURE__ */ new Error(`${kind} worker was reset`));
-		if (readiness) {
-			rejectWorkerReadiness(readiness, /* @__PURE__ */ new Error(`${kind} worker was reset`));
-			this.deleteWorkerReadiness(kind);
-		}
-		const messageHandler = this.messageHandlers.get(kind);
-		const errorHandler = this.errorHandlers.get(kind);
-		if (messageHandler) worker.removeEventListener("message", messageHandler);
-		if (errorHandler) worker.removeEventListener("error", errorHandler);
-		worker.terminate();
-		this.workers.delete(kind);
-		this.messageHandlers.delete(kind);
-		this.errorHandlers.delete(kind);
-		if (kind === "walletCustodyCeremony") dropUnlockedWalletEd25519ExportRootCapabilityReferenceV1();
-	}
-	readinessForWorker(kind) {
-		if (!isWasmPrewarmWorkerKind(kind)) return void 0;
-		return this.workerReadiness.get(kind);
-	}
-	deleteWorkerReadiness(kind) {
-		if (!isWasmPrewarmWorkerKind(kind)) return;
-		this.workerReadiness.delete(kind);
-	}
-};
-const workerTransport = new WorkerTransport();
-function getWorkerTransport() {
-	return workerTransport;
-}
-//#endregion
-export { getWorkerTransport };
-
-//# sourceMappingURL=workerTransport.js.map