@awiki/dsh-plugin 0.3.7 → 0.3.10

package/lib/{sdk-adapter--trNlr-T.mjs → sdk-adapter-CYcJH7sM.mjs}

@@ -1,3 +1,105 @@
+//#region lib/types/mail-recovery-observability.js
+const MAIL_INGRESS_CLASSIFICATIONS = /* @__PURE__ */ new Set([
+	"reached",
+	"not_reached",
+	"unknown"
+]);
+const AUTH_STATUS_CLASSES = /* @__PURE__ */ new Set([
+	"accepted",
+	"rejected",
+	"dependency_unavailable",
+	"unknown"
+]);
+const MAIL_CLOSED_CLASSIFICATIONS = /* @__PURE__ */ new Set([
+	"success",
+	"authentication_rejected",
+	"dependency_unavailable",
+	"no_active_handle",
+	"multiple_active_handles",
+	"no_mailbox",
+	"owner_conflict",
+	"unknown"
+]);
+const STABLE_MACHINE_CODE = /^[a-z0-9](?:[a-z0-9._-]{0,126}[a-z0-9])?$/u;
+const CLOSED_FAILURE_TUPLES = /* @__PURE__ */ new Set([
+	"reached:rejected:authentication_rejected",
+	"reached:dependency_unavailable:dependency_unavailable",
+	"not_reached:dependency_unavailable:dependency_unavailable",
+	"reached:accepted:no_active_handle",
+	"reached:accepted:multiple_active_handles",
+	"reached:accepted:no_mailbox",
+	"reached:accepted:owner_conflict"
+]);
+function property(value, key) {
+	try {
+		return typeof value === "object" && value !== null ? value[key] : void 0;
+	} catch {
+		return;
+	}
+}
+function optionalProperty(value, key) {
+	try {
+		if (typeof value !== "object" || value === null || !(key in value)) return { status: "absent" };
+		return {
+			status: "present",
+			value: value[key]
+		};
+	} catch {
+		return { status: "unreadable" };
+	}
+}
+/** Copy only a complete upstream closed classification; arbitrary errors fail closed. */
+function mailRecoveryFailureFields(error) {
+	const ingress = property(error, "mail_ingress_classification");
+	const authStatus = property(error, "auth_status_class");
+	const closed = property(error, "mail_closed_classification");
+	const retryable = property(error, "retryable");
+	if (typeof ingress !== "string" || !MAIL_INGRESS_CLASSIFICATIONS.has(ingress) || typeof authStatus !== "string" || !AUTH_STATUS_CLASSES.has(authStatus) || typeof closed !== "string" || !MAIL_CLOSED_CLASSIFICATIONS.has(closed) || ingress === "unknown" || authStatus === "unknown" || closed === "unknown" || closed === "success" || typeof retryable !== "boolean") return void 0;
+	const tuple = `${ingress}:${authStatus}:${closed}`;
+	if (!CLOSED_FAILURE_TUPLES.has(tuple)) return void 0;
+	const stableCode = optionalProperty(error, "auth_stable_machine_code");
+	if (stableCode.status === "unreadable" || stableCode.status === "present" && (typeof stableCode.value !== "string" || !STABLE_MACHINE_CODE.test(stableCode.value)) || stableCode.status === "present" && authStatus === "accepted") return void 0;
+	return {
+		mail_ingress_classification: ingress,
+		auth_status_class: authStatus,
+		...stableCode.status === "present" ? { auth_stable_machine_code: stableCode.value } : {},
+		retryable,
+		mail_closed_classification: closed
+	};
+}
+function successfulMailRecoveryObservability() {
+	return {
+		current_principal_matches_recovery: true,
+		request_generation_classification: "current",
+		mail_ingress_classification: "reached",
+		auth_status_class: "accepted",
+		retryable: false,
+		mail_closed_classification: "success"
+	};
+}
+function failedMailRecoveryObservability(error) {
+	return {
+		current_principal_matches_recovery: true,
+		request_generation_classification: "current",
+		...mailRecoveryFailureFields(error) ?? {
+			mail_ingress_classification: "unknown",
+			auth_status_class: "unknown",
+			retryable: false,
+			mail_closed_classification: "unknown"
+		}
+	};
+}
+function fencedMailRecoveryObservability(currentPrincipalMatchesRecovery, requestGenerationClassification) {
+	return {
+		current_principal_matches_recovery: currentPrincipalMatchesRecovery,
+		request_generation_classification: requestGenerationClassification,
+		mail_ingress_classification: currentPrincipalMatchesRecovery ? "unknown" : "not_reached",
+		auth_status_class: "unknown",
+		retryable: false,
+		mail_closed_classification: "unknown"
+	};
+}
+//#endregion
 //#region lib/types/sdk-adapter.js
 /** Rust IM Core adapter that copies native values into Host-owned public DTOs. */
 const GROUP_LOOKUP_LIMIT = 100;
@@ -17,14 +119,16 @@ const RUST_FAILURE_CODES = {
 	permission_denied: "forbidden",
 	group_not_member: "group-membership-required",
 	group_identity_stale: "group-identity-stale",
-	auth_revoked: "identity-recovery-required",
+	auth_revoked: "device-rejoin-required",
+	local_identity_recovery_required: "identity-recovery-required",
 	conflict: "conflict",
 	join_required: "handle-unavailable",
-	state_in_use: "state-in-use",
+	state_in_use: "conflict",
 	rate_limited: "rate-limited",
 	timeout: "network",
 	transport_unavailable: "network",
 	sync_failed: "network",
+	sync_blocked: "conflict",
 	session_expired: "network",
 	attachment_transfer_network: "network",
 	recovery_reconciliation_unavailable: "network",
@@ -33,15 +137,54 @@ const RUST_FAILURE_CODES = {
 /** Closed provider error consumed by the Host's fixed public failure mapping. */
 var AwikiSdkError = class extends Error {
 	code;
+	realtimeFailureCode;
 	name = "AwikiSdkError";
-	constructor(code) {
+	mail_ingress_classification;
+	auth_status_class;
+	auth_stable_machine_code;
+	retryable;
+	mail_closed_classification;
+	constructor(code, realtimeFailureCode, mailRecoveryFailure) {
 		super(`AWiki SDK operation failed: ${code}`);
 		this.code = code;
+		this.realtimeFailureCode = realtimeFailureCode;
+		if (mailRecoveryFailure !== void 0) Object.assign(this, mailRecoveryFailure);
 	}
 };
 function fail(code = "remote") {
 	throw new AwikiSdkError(code);
 }
+const REALTIME_RETRY_WARNING_PRIORITY = [
+	"sync.retry.local_state.actor_closed",
+	"sync.retry.local_state.database_busy",
+	"sync.retry.local_state.constraint_failed",
+	"sync.retry.local_state.schema_unavailable",
+	"sync.retry.local_state.storage_unavailable",
+	"sync.retry.local_state.codec_unavailable",
+	"sync.retry.local_state.other",
+	"sync.retry.transport_unavailable",
+	"sync.retry.service_unavailable",
+	"sync.retry.local_state_unavailable"
+];
+function realtimeSyncFailureCode(status, warnings, errorCode) {
+	if (status === "retryable_failure") return REALTIME_RETRY_WARNING_PRIORITY.find((code) => warnings.includes(code)) ?? "sync.retryable_failure";
+	if (status === "recovery_required") return "sync.recovery_required";
+	if (status === "auth_revoked") return "sync.auth_revoked";
+	if (status === "blocked") {
+		if (errorCode === "sync.client_upgrade_required") return "sync.blocked.client_upgrade_required";
+		if (errorCode === "device_reprovision_required") return "sync.blocked.device_reprovision_required";
+		if (errorCode === "server_repair_required") return "sync.blocked.server_repair_required";
+		if (errorCode === "sync.snapshot_item_too_large" || errorCode === "sync.snapshot_required_state_too_large") return "sync.blocked.snapshot_capacity";
+		if (errorCode === "sync.invalid_request") return "sync.blocked.invalid_request";
+		if (errorCode === "sync.invalid_cursor") return "sync.blocked.invalid_cursor";
+		return errorCode === void 0 ? "sync.blocked" : "sync.blocked.other";
+	}
+	return "sync.unexpected_status";
+}
+function syncResultErrorCode(result) {
+	if (!("errorCode" in result)) return void 0;
+	return typeof result.errorCode === "string" ? result.errorCode : void 0;
+}
 function mapError(error, ambiguousSend = false) {
 	if (error instanceof AwikiSdkError) throw error;
 	let code = "remote";
@@ -51,7 +194,7 @@ function mapError(error, ambiguousSend = false) {
 			if (value.name === "ImCoreNodeError" && typeof value.code === "string") code = ambiguousSend && (value.code === "timeout" || value.code === "transport_unavailable") ? "delivery-unknown" : RUST_FAILURE_CODES[value.code] ?? "remote";
 		}
 	} catch {}
-	fail(code);
+	throw new AwikiSdkError(code, void 0, mailRecoveryFailureFields(error));
 }
 function safeInteger(value, minimum = 0) {
 	if (!/^(?:0|[1-9]\d*)$/u.test(value)) fail();
@@ -89,14 +232,6 @@ function mailAddress(value) {
 	if (length < 3 || length > 320 || !value.includes("@") || /[\s\u0000-\u001f\u007f-\u009f]/u.test(value)) fail();
 	return value;
 }
-function mailFileName(value) {
-	if (typeof value !== "string" || value.length === 0 || value.trim() !== value || value.replace(/[. ]+$/u, "") !== value || value === "." || value === ".." || Buffer.byteLength(value, "utf8") > 255 || /[\\/\p{C}]/u.test(value)) fail();
-	return value;
-}
-function mailContentType(value) {
-	if (typeof value !== "string" || !/^[A-Za-z0-9!#$&^_.+-]+\/[A-Za-z0-9!#$&^_.+-]+$/u.test(value)) fail();
-	return value;
-}
 function mailAddresses(value) {
 	if (!Array.isArray(value) || value.length > 100) fail();
 	return value.map(mailAddress);
@@ -111,11 +246,6 @@ function uint32(value) {
 	if (!Number.isSafeInteger(value) || value < 0 || value > 4294967295) fail();
 	return value;
 }
-function recoveryE2eeGroupCount(impact) {
-	if (typeof impact !== "object" || impact === null) fail();
-	const value = impact;
-	return uint32(value.unsupportedE2eeGroupCount !== void 0 ? value.unsupportedE2eeGroupCount : value.unsupportedE2EeGroupCount);
-}
 function boolean(value) {
 	if (typeof value !== "boolean") fail();
 	return value;
@@ -205,6 +335,26 @@ function identity(value) {
 		registeredAt: safeInteger(value.registeredAtMs)
 	};
 }
+function joinProgress(value) {
+	return {
+		joinSessionId: required(value.joinSessionId),
+		localPhase: value.localPhase,
+		remoteState: value.remoteState,
+		expiresAt: required(value.expiresAt),
+		...value.sas === void 0 ? {} : { sas: required(value.sas) },
+		completed: boolean(value.completed),
+		...value.identity === void 0 ? {} : { identity: identity(value.identity) }
+	};
+}
+function adminJoinProgress(value) {
+	return {
+		joinSessionId: required(value.joinSessionId),
+		localPhase: value.localPhase,
+		remoteState: value.remoteState,
+		expiresAt: required(value.expiresAt),
+		...value.sas === void 0 ? {} : { sas: required(value.sas) }
+	};
+}
 function profile(value) {
 	return {
 		did: required(value.did),
@@ -312,20 +462,51 @@ function externalHttpAttempt(value) {
 }
 /** Adapt the Rust Node bridge to the frozen Host provider interface. */
 var RustSdkAdapter = class {
+	trustedUserPresenceSupported = process.platform === "darwin" && process.arch === "x64";
 	client;
+	refreshingDisplayPeers = /* @__PURE__ */ new Set();
+	scheduleDisplayRefresh(client, peers) {
+		if (this.disposal !== void 0) return;
+		const pending = [...new Set(peers)].filter((peer) => peer.startsWith("did:") && !this.refreshingDisplayPeers.has(peer)).slice(0, 100);
+		if (pending.length === 0) return;
+		for (const peer of pending) this.refreshingDisplayPeers.add(peer);
+		client.refreshDisplayProfiles({ peers: pending }).catch(() => void 0).finally(() => {
+			for (const peer of pending) this.refreshingDisplayPeers.delete(peer);
+		});
+	}
+	getDisplayProfiles(peers) {
+		return this.run(async (client) => {
+			const profiles = await client.hydrateDisplayProfiles({ peers });
+			this.scheduleDisplayRefresh(client, peers);
+			return profiles.flatMap((profile) => profile.did === void 0 ? [] : [{
+				did: profile.did,
+				cacheHit: profile.cacheHit,
+				...profile.handle === void 0 ? {} : { handle: profile.handle },
+				...profile.displayName === void 0 ? {} : { displayName: profile.displayName }
+			}]);
+		});
+	}
 	attachmentConversations = /* @__PURE__ */ new Map();
 	disposal;
+	realtime;
+	agentInbox;
 	listener;
 	constructor(client) {
 		this.client = Promise.resolve(client);
-		this.listener = {
+		this.realtime = {
 			syncNow: (reason) => this.listenerSyncNow(reason),
-			startRealtime: () => this.listenerStartRealtime(),
+			startRealtime: () => this.listenerStartRealtime()
+		};
+		this.agentInbox = {
 			listConversations: (request) => this.listenerConversations(request),
 			getHistory: (request) => this.listenerHistory(request),
 			markConversationRead: (conversationId) => this.markConversationRead(conversationId),
 			sendText: (request) => this.sendText(request)
 		};
+		this.listener = {
+			...this.realtime,
+			...this.agentInbox
+		};
 	}
 	async run(operation, ambiguousSend = false) {
 		try {
@@ -336,16 +517,18 @@ var RustSdkAdapter = class {
 	}
 	async displayableMessages(client, values) {
 		const messages = values.filter(displayableMessage);
-		const peers = [...new Set(messages.filter((message) => message.conversationKind === "group" && !message.outgoing && message.senderHandle === void 0 && message.senderDisplayName === void 0).map((message) => message.senderDid))];
+		const peers = [...new Set(messages.filter((message) => message.conversationKind === "group" && !message.outgoing).map((message) => message.senderDid))];
 		if (peers.length === 0) return [...messages];
 		const profiles = await client.hydrateDisplayProfiles({ peers });
+		this.scheduleDisplayRefresh(client, peers);
 		const byDid = /* @__PURE__ */ new Map();
 		for (const profile of profiles) if (profile.did !== void 0) byDid.set(profile.did, profile);
 		return messages.map((message) => {
 			const profile = byDid.get(message.senderDid);
-			if (profile === void 0) return message;
+			if (profile === void 0 || !profile.cacheHit) return message;
+			const { senderDisplayName: _snapshot, ...rest } = message;
 			return {
-				...message,
+				...rest,
 				...profile.handle === void 0 ? {} : { senderHandle: profile.handle },
 				...profile.displayName === void 0 ? {} : { senderDisplayName: profile.displayName }
 			};
@@ -478,7 +661,7 @@ var RustSdkAdapter = class {
 			...value.peerPersonaId === void 0 ? {} : { peerPersonaId: value.peerPersonaId },
 			...value.did === void 0 ? {} : { did: value.did },
 			...value.credentialDid === void 0 ? {} : { credentialDid: value.credentialDid },
-			...value.handle === void 0 ? {} : { handle: value.handle },
+			...(profile?.handle ?? value.handle) === void 0 ? {} : { handle: profile?.handle ?? value.handle },
 			...profile?.displayName === void 0 ? {} : { displayName: profile.displayName },
 			...value.role === void 0 ? {} : { role: value.role },
 			...value.status === void 0 ? {} : { status: value.status },
@@ -527,9 +710,12 @@ var RustSdkAdapter = class {
 	listenerSyncNow(reason) {
 		return this.run(async (client) => {
 			const result = await client.syncNow({ reason });
-			if (result.status === "idle" || result.status === "changed") return;
-			if (result.status === "auth_revoked") fail("identity-recovery-required");
-			fail("network");
+			if (result.status === "idle" || result.status === "changed") return {
+				pagesFetched: uint32(result.pagesFetched),
+				messagesHydrated: uint32(result.messagesHydrated),
+				olderHistoryExcluded: boolean(result.olderHistoryExcluded)
+			};
+			throw new AwikiSdkError(result.status === "auth_revoked" ? "device-rejoin-required" : "network", realtimeSyncFailureCode(result.status, result.warnings, syncResultErrorCode(result)));
 		});
 	}
 	listenerStartRealtime() {
@@ -537,6 +723,9 @@ var RustSdkAdapter = class {
 			const session = await client.startRealtime();
 			return {
 				nextEvent: () => this.run(() => session.nextEvent()),
+				getStatus: () => this.run(async () => {
+					return { connected: (await session.getStatus()).connected };
+				}),
 				stop: () => this.run(() => session.stop())
 			};
 		});
@@ -599,7 +788,144 @@ var RustSdkAdapter = class {
 		});
 	}
 	registerIdentity(request) {
-		return this.run(async (client) => identity(await client.completeRegistration(request)));
+		return this.run(async (client) => {
+			const value = await client.completeRegistrationWithOutcome(request);
+			if (value.status === "registered") return {
+				status: "registered",
+				identity: identity(value.identity)
+			};
+			return {
+				status: "join-required",
+				continuationId: required(value.existingHandle.continuationId),
+				fullHandle: required(value.existingHandle.fullHandle),
+				mode: value.existingHandle.mode === "handle_recovery_rebind" ? "handle-recovery-rebind" : "ordinary",
+				requiresUserPresence: boolean(value.existingHandle.requiresUserPresence)
+			};
+		});
+	}
+	beginDeviceJoin(request) {
+		return this.run(async (client) => joinProgress(await client.beginPreparedRegistrationJoin(request)));
+	}
+	getDeviceJoinStatus(joinSessionId) {
+		return this.run(async (client) => joinProgress(await client.resumePreparedRegistrationJoin({ joinSessionId })));
+	}
+	listLocalDeviceJoinSessions() {
+		return this.run(async (client) => (await client.listLocalDeviceJoinSessions()).map((value) => ({
+			joinSessionId: required(value.joinSessionId),
+			side: value.side,
+			localPhase: value.localPhase,
+			expiresAt: required(value.expiresAt)
+		})));
+	}
+	cancelDeviceJoin(joinSessionId) {
+		return this.run(async (client) => {
+			const value = await client.cancelPreparedRegistrationJoin({ joinSessionId });
+			return {
+				joinSessionId: required(value.joinSessionId),
+				side: value.side,
+				localPhase: value.localPhase,
+				expiresAt: required(value.expiresAt)
+			};
+		});
+	}
+	getCurrentDeviceSummary() {
+		return this.run(async (client) => {
+			const value = await client.getCurrentDeviceSummary();
+			return {
+				...value.role === void 0 ? {} : { role: value.role },
+				readiness: value.readiness,
+				canManage: boolean(value.canManage)
+			};
+		});
+	}
+	syncDeviceManagement() {
+		return this.run(async (client) => {
+			await client.syncNow({ reason: "foreground_reconcile" });
+		});
+	}
+	getDeviceRegistry() {
+		return this.run(async (client) => (await client.getDeviceRegistry()).devices.map((value) => ({
+			deviceId: required(value.protocolDeviceId),
+			status: value.status,
+			role: value.role,
+			managementReady: boolean(value.managementReady),
+			isCurrent: boolean(value.isCurrent)
+		})));
+	}
+	listLocalDeviceJoinRequests() {
+		return this.run(async (client) => (await client.listLocalDeviceJoinRequests()).map((value) => ({
+			joinSessionId: required(value.joinSessionId),
+			protocolDeviceId: required(value.protocolDeviceId),
+			candidateKeyFingerprint: required(value.candidateKeyFingerprint),
+			issuedAt: required(value.issuedAt),
+			expiresAt: required(value.expiresAt),
+			state: value.state,
+			claimedByCurrentDevice: boolean(value.claimedByCurrentDevice),
+			canStartVerification: boolean(value.canStartVerification)
+		})));
+	}
+	startDeviceJoinVerification(request) {
+		return this.run(async (client) => adminJoinProgress(await client.startDeviceJoinVerification(request)));
+	}
+	getLocalDeviceJoinVerificationProgress(joinSessionId) {
+		return this.run(async (client) => adminJoinProgress(await client.getLocalDeviceJoinVerificationProgress({ joinSessionId })));
+	}
+	prepareDeviceJoinApproval(joinSessionId) {
+		return this.run(async (client) => {
+			return { approvalHandle: required((await client.prepareDeviceJoinApproval({
+				joinSessionId,
+				sasConfirmed: true
+			})).approvalHandle) };
+		});
+	}
+	confirmDeviceJoinApproval(approvalHandle) {
+		return this.run(async (client) => adminJoinProgress(await client.confirmDeviceJoinApproval({
+			approvalHandle,
+			userPresenceConfirmed: true
+		})));
+	}
+	rejectDeviceJoin(joinSessionId, reason) {
+		return this.run(async (client) => adminJoinProgress(await client.rejectDeviceJoin({
+			joinSessionId,
+			reason
+		})));
+	}
+	revokeDevice(deviceId) {
+		return this.run(async (client) => {
+			await client.revokeDevice({
+				targetDeviceId: deviceId,
+				userPresenceConfirmed: true
+			});
+		});
+	}
+	confirmUserPresence(reason) {
+		return this.run((client) => client.confirmUserPresence({ reason }));
+	}
+	prepareRootKeyTransfer(deviceId) {
+		return this.run(async (client) => {
+			const value = await client.prepareRootKeyTransfer({ recipientDeviceId: deviceId });
+			return {
+				authorizationHandle: required(value.authorizationHandle),
+				recipient: {
+					did: required(value.recipient.did),
+					deviceId: required(value.recipient.deviceId),
+					registryVersion: required(value.recipient.registryVersion)
+				},
+				expiresAt: required(value.expiresAt)
+			};
+		});
+	}
+	confirmAndSendRootKeyTransfer(authorizationHandle) {
+		return this.run(async (client) => {
+			const value = await client.confirmAndSendRootKeyTransfer({
+				authorizationHandle,
+				userPresenceConfirmed: true
+			});
+			return {
+				recipientDeviceId: required(value.recipientDeviceId),
+				acceptedAt: required(value.acceptedAt)
+			};
+		});
 	}
 	updateDisplayName(request) {
 		return this.run(async (client) => identity(await client.updateDisplayName(request.displayName)));
@@ -621,12 +947,11 @@ var RustSdkAdapter = class {
 			...value.previousDid === void 0 ? {} : { previousDid: value.previousDid },
 			currentDid: required(value.currentDid),
 			phase: value.phase,
+			allowedActions: [...value.allowedActions ?? []],
 			...value.failureCode === void 0 ? {} : { failureCode: value.failureCode },
 			retryable: boolean(value.retryable),
 			localOrdinaryDataWillMigrate: boolean(value.impact.localOrdinaryDataWillMigrate),
-			otherDevicesMustRejoin: boolean(value.impact.otherDevicesMustRejoin),
-			unsupportedE2eeGroupCount: recoveryE2eeGroupCount(value.impact),
-			unsupportedDidOnlyGroupCount: uint32(value.impact.unsupportedDidOnlyGroupCount)
+			otherDevicesMustRejoin: boolean(value.impact.otherDevicesMustRejoin)
 		};
 	}
 	sendRecoveryOtp(request) {
@@ -646,21 +971,18 @@ var RustSdkAdapter = class {
 	activateRecovery(request) {
 		return this.run(async (client) => this.recoveryProgress(await client.activateHandleRecovery(request)));
 	}
+	listPendingRecoveries() {
+		return this.run(async (client) => (await client.listPendingHandleRecoveryOperations()).map((value) => ({
+			operationId: required(value.operationId),
+			fullHandle: required(value.fullHandle)
+		})));
+	}
 	getRecoveryStatus(request) {
 		return this.run(async (client) => this.recoveryProgress(await client.getHandleRecoveryStatus(request)));
 	}
 	resumeRecovery(request) {
 		return this.run(async (client) => this.recoveryProgress(await client.resumeHandleRecovery(request)));
 	}
-	issueRecoveryAttestation(request) {
-		return this.run(async (client) => {
-			const value = await client.issueHandleRecoveryAttestation(request);
-			return {
-				attestation: required(value.attestation),
-				expiresAt: required(value.expiresAt)
-			};
-		});
-	}
 	discardRecovery(request) {
 		return this.run(async (client) => {
 			await client.discardHandleRecovery(request);
@@ -704,6 +1026,7 @@ var RustSdkAdapter = class {
 			});
 			const peers = [...new Set(value.items.flatMap((member) => member.did ?? member.handle ?? []))];
 			const profiles = peers.length === 0 ? [] : await client.hydrateDisplayProfiles({ peers });
+			this.scheduleDisplayRefresh(client, peers);
 			const byPeer = /* @__PURE__ */ new Map();
 			for (const [index, profile] of profiles.entries()) {
 				const requested = peers[index];
@@ -728,41 +1051,6 @@ var RustSdkAdapter = class {
 			member
 		})));
 	}
-	resumeGroupRebindRecovery() {
-		return this.run(async (client) => {
-			const value = await client.resumeGroupRebindRecovery(100);
-			const journal = value;
-			const statuses = /* @__PURE__ */ new Map();
-			for (const item of journal.items ?? []) {
-				const { groupDid: rawGroupDid, layer: rawLayer, phase: rawPhase } = item;
-				if (typeof rawGroupDid !== "string" || typeof rawLayer !== "string" || typeof rawPhase !== "string" || typeof item.blocked !== "boolean") throw new TypeError("invalid group recovery item");
-				const groupDid = required(rawGroupDid);
-				const layer = required(rawLayer);
-				const phase = required(rawPhase);
-				if (layer !== "p4" && layer !== "p6") throw new TypeError("invalid group recovery item");
-				if (phase === "complete") continue;
-				const status = item.blocked || phase === "blocked" ? "blocked" : "pending";
-				if (statuses.get(groupDid) !== "blocked") statuses.set(groupDid, status);
-			}
-			for (const group of journal.sendPausedGroups ?? []) {
-				if (typeof group !== "string") throw new TypeError("invalid paused recovery group");
-				const groupDid = required(group);
-				if (!statuses.has(groupDid)) statuses.set(groupDid, "pending");
-			}
-			const items = [...statuses].map(([groupDid, status]) => ({
-				groupDid,
-				status
-			}));
-			const hasJournal = journal.items !== void 0 || journal.sendPausedGroups !== void 0;
-			return {
-				processed: uint32(value.processed),
-				completed: uint32(value.completed),
-				pending: hasJournal ? items.filter((item) => item.status === "pending").length : uint32(value.pending),
-				blocked: hasJournal ? items.filter((item) => item.status === "blocked").length : uint32(value.blocked),
-				items
-			};
-		});
-	}
 	listConversations(request) {
 		return this.run(async (client) => {
 			const conversations = await client.listConversations(request);
@@ -884,21 +1172,12 @@ var RustSdkAdapter = class {
 		});
 	}
 	sendMail(request) {
-		const attachments = request.attachments?.map((attachment) => ({
-			fileName: attachment.fileName,
-			contentType: attachment.contentType,
-			bytes: Uint8Array.from(attachment.bytes)
-		}));
 		return this.run(async (client) => {
-			const input = {
+			const value = await client.sendMail({
 				to: [...request.to],
 				...request.cc === void 0 ? {} : { cc: [...request.cc] },
 				subject: request.subject,
 				bodyText: request.bodyText
-			};
-			const value = await client.sendMail({
-				...input,
-				...attachments === void 0 || attachments.length === 0 ? {} : { attachments }
 			});
 			if (!Array.isArray(value.warnings) || value.warnings.length > 100) fail();
 			const messageId = value.messageId === void 0 ? void 0 : mailToken(value.messageId, 2048);
@@ -909,25 +1188,19 @@ var RustSdkAdapter = class {
 			};
 		}, true);
 	}
-	downloadMailAttachment(request) {
-		return this.run(async (client) => {
-			const value = await client.downloadMailAttachment({
-				messageId: mailToken(request.messageId, 2048),
-				attachmentIndex: uint32(request.attachmentIndex)
-			});
-			const sizeBytes = safeInteger(remoteString(value.sizeBytes, 20));
-			if (!(value.bytes instanceof Uint8Array) || value.bytes.byteLength !== sizeBytes) fail();
-			return {
-				fileName: mailFileName(value.fileName),
-				contentType: mailContentType(value.contentType),
-				sizeBytes,
-				bytes: Uint8Array.from(value.bytes)
-			};
-		});
-	}
 	clearLocalData() {
 		return this.run((client) => client.clearLocalData());
 	}
+	retireDefaultIdentityForRejoin() {
+		return this.run((client) => {
+			const retire = client.retireDefaultIdentityForRejoin;
+			if (typeof retire !== "function") throw Object.assign(/* @__PURE__ */ new Error("device rejoin is unavailable in this IM Core build"), {
+				name: "AwikiSdkError",
+				code: "remote"
+			});
+			return retire.call(client);
+		});
+	}
 	dispose() {
 		this.disposal ??= this.client.then(async (client) => {
 			try {
@@ -951,4 +1224,4 @@ function downloadedAttachment(value) {
 	};
 }
 //#endregion
-export { downloadedAttachment as n, RustSdkAdapter as t };
+export { fencedMailRecoveryObservability as a, failedMailRecoveryObservability as i, RustSdkAdapter as n, successfulMailRecoveryObservability as o, downloadedAttachment as r, AwikiSdkError as t };