@ghostlytools/cli 1.0.1 → 1.0.3

package/dist/assets/{server-C-8wbsAX.js → server-BnNXYzR9.js}

@@ -1,4 +1,7 @@
-import { $ as boundedIdentityFetch, $n as LIVENESS_PING_MS, $r as IDENTITY_REVOCATION_LABEL, $t as GroupWakeLimiter, A as TEST_MINT, Ai as ReactionWindow, An as assertTokenUnits, Ar as nextPinNumber, At as transact, B as registeredLightningProviders, Ba as toZ32, Bi as replySnippet, Bn as isPubkyKey, Br as vapidKeysMatch, Bt as communityHasFrame, C as networkLabel, Ca as normalizeRelayUrl, Ci as dhtEditId, Cn as ONCHAIN_PROVIDER, Cr as transferEnded, Ct as STORES, D as WALLET_TYPES, Da as PacketTooLargeError, Di as COMMUNITY_REACTION_FRAME, Dn as TEST_USDT_FAUCET_AMOUNT, Dt as fileStore, Ea as withRequestOptions, Ei as readForwarded, En as SEPOLIA_TEST_USDT_FAUCET, Er as typingActivity, Et as deleteDatabase, F as paysItsOwnInvoices, Fa as sanitizeAvatar, Fi as readReaction, Fn as SPARK_NETWORKS, Fr as WakeLimiter, Ft as openGroupTyping, G as SourceConfigError, Gi as statusCardText, Gn as cashuRequestPayload, Gr as HoldKeys, Gt as decodeGroupEntryLink, H as reserveAdapterIds, Ha as utf8Encode, Hi as STATUS_CARD_LIMITS, Hn as engineText, Hr as EDIT_CAPABILITY, Ht as decodeCommunityLink, I as BACKUP_MEDIA_TYPE, Ia as bytesEqual, Ii as validReactionNumber, In as SPARK_PROVIDER, Ir as newWakeToken, It as sealGroupTyping, J as networkMode, Jn as isFederationId, Jr as readManifest, Jt as knockIdentity, K as SourceUnreachableError, Ki as receivedTimestamp, Kn as fedimintRequestPayload, Kr as HoldRefusedError, Kt as encodeGroupEntryLink, L as MAX_BACKUP_BYTES, La as fromBase64Url, Li as wireReaction, Ln as sparkAddressKind, Lr as relayRequest, Lt as COMMUNITY_LIMITS, M as isTestMint, Ma as identityFromSeed, Mi as queueReaction, Mn as formatPaymentAmount, Mr as pinNumberHolds, N as isWorthlessMint, Na as identityFromSeedB64, Ni as reactionEmoji, Nn as validatePaymentTarget, Nr as readPin, Nt as GroupTypingBoard, O as BITCOIN_INVOICE_ON_TESTNET, Oi as GROUP_REACTION_FRAME, On as USDT_PUBLIC_RPC, Or as PIN_LIMITS, Ot as openDb, P as mintNetwork, Pa as publicKeyFromZ32, Pi as reactionIsNewer, Pn as walletNetworkOf, Pr as WAKE_CALL_INTERVAL_MS, Pt as groupTypingEpoch, Q as setOwnDidSource, Qi as edgeParams, Qn as INVITE_TAKEN, Qr as dialDescriptors, R as identityProviders, Ra as randomBytes, Ri as pairedReplyAuthor, Rn as sparkInvoiceDetails, Rr as wakeRequest, Rt as CommunitySession, S as WrongNetworkError, Sa as currentRelays, Si as RateWindow, Sn as EVM_TEST_CHAINS, Sr as FILE_LIMITS, T as cashuMint, Ta as isDiscoveryBudgetError, Ti as forwardedAgain, Tn as SEPOLIA_TEST_USDT, Tr as TypingSender, Tt as databaseName, U as NothingSpentError, Ua as __exportAll, Ui as checkStatusCard, Un as decodeBolt11, Ur as HOLD_CAPABILITY, Ut as encodeCommunityLink, V as registeredOnchainProviders, Va as utf8Decode, Vi as BUTTON_ID, Vn as engineError, Vt as communityMessageId, W as PROVIDER_PLATFORMS, Wi as sameButtonText, Wn as ENDPOINT, Wr as HOLD_LIMITS, X as assertPublicServer, Xi as rosterHas, Xn as parseFedimintRequestPayload, Xr as DHT_TEXT_CAPABILITY, Xt as mergeKnocks, Y as redact, Yi as MEMBER_KEY, Yn as parseCashuRequestPayload, Yr as CapsExchange, Yt as knockRecords, Z as resolveAtprotoDid, Zi as verifyCommitSignature, Zn as GhostLink, Zr as capsDescriptors, Zt as readKnocks, _ as newDeviceKey, _a as decodeInviteCode, _i as parseVideoMeta, _n as didDhtFromPublicKey, _r as readBeacon, _t as fileBytes, a as createFailure, aa as webLocalFetch, ai as receivedIdentityStatus, an as GroupSession, ar as COMMUNITY_TOPOLOGY, at as replyRef, b as ModeChanged, ba as DEFAULT_RELAYS, bi as EDIT_BUFFER_MS, bn as signDidDhtPacket, br as shouldBeHub, bt as removeFileBytes, c as paymentNetwork, ca as encodeControl, ci as PeerProofs, cr as doorHubs, ct as paymentWireId, d as networkReason, da as emptyLinkRecords, di as TRANSPORTS, dn as parseCommunityEdit, dr as lobbyRecords, dt as removeStored, ea as RELAY_POLL_INTERVALS, ei as IdentityExchange, en as groupWakeFrame, er as pairedMessageFrame, et as verifyIdentity, f as rpcHost, fa as HTTP_SERVICE_PROTO, fi as automaticTransport, fn as mentionsMember, fr as mergeBeacon, ft as storedSize, g as intentRepository, ga as createChatInvite, gi as parseVoiceMeta, gn as didDhtDocument, gr as rankHubs, h as ProviderSources, ha as OwnInviteError, hi as fileMessageText, hn as normalizeAtprotoHandle, hr as pickHubs, ht as blobDigest, i as assertConfirmedReal, ia as parseLocalTarget, ii as newIdentityBinding, in as GROUP_READ_NOTE, ir as pickMeshHubs, it as receivedPairedReply, j as fakesLightning, ja as createIdentity, ji as nextReactionNumber, jn as assertWholeSats, jr as pinIsNewer, jt as wrap, k as DEFAULT_MINTS, ki as REACTION_LIMITS, kn as WALLET_NETWORKS, kr as mayPin, kt as store, l as paymentNetworksOf, la as RTC_CONFIG, li as emptyProofLedger, ln as GROUP_EDIT_TEXT_BYTES, lr as freshHubs, lt as FileAppender, m as LightningCards, ma as serviceIdFromName, mi as safeBlobType, mn as isAtprotoDid, mr as newerHead, n as loadFedimintSdk, na as GhostlyHttpError, ni as identityRevocationValue, nn as parseGroupWakeFrame, nr as mayBeHub, nt as groupReply, o as createTiming, oa as LIMITS, oi as revokesIdentity, on as groupMessageId, or as beaconKeys, ot as replyTo, p as CASHU_CARD, pa as LEGACY_SERVICES, pi as parseImageMeta, pn as groupName, pr as mergeLobby, pt as streamStored, q as isNothingSpentError, qi as GROUP_MEMBER_CAP, qn as findEndpoint, qr as newMailbox, qt as entryParams, r as WALLET_NAMES, ra as formatLocalTarget, ri as identityStatement, rr as meshHubs, rt as pairedWireReply, s as crossNetwork, sa as decodeControl, si as lastSharedWithMe, sr as beaconRecords, st as paymentAlias, t as fedimintDatabase, ta as traceLink, ti as emptyIdentityLedger, tn as groupWakes, tr as MESH_HUBS, tt as chosenResolver, u as walletInstances, ua as parseCallSignal, ui as validExternalKey, un as carryMentions, ur as lobbyKeys, ut as readStored, v as sealSeed, va as encodeInviteCode, vi as DHT_MESSAGE_TTL, vn as encodeDidDhtDeactivated, vr as readBeaconHead, vt as fileBytesOf, w as CASHU_MINT_SOURCE, wa as budgetRetryMs, wi as parseLinkPreview, wn as PaymentPreflightError, wr as transferStalled, wt as clearProfileStores, x as ModeGate, xa as RelayTransport, xi as EDIT_RATE_WINDOW_MS, xn as ETHEREUM_USDT, xr as ChatFiles, y as unsealSeed, ya as inviteOwnership, yi as peekDhtMailbox, yn as encodeDidDhtPacket, yr as readLobby, z as onAdaptersChanged, za as toBase64Url, zi as readReply, zn as isBitcoinAddress, zr as checkPushEndpoint, zt as GROUP_READ_NOTE_COMMUNITY } from "../ghostly.mjs";
+import { a as fileBytesOf, c as removeFileBytes, d as __exportAll, i as fileBytes, n as blobDigest } from "./fileBytes-Br_MpeNT.js";
+import { $a as createIdentity, $i as heardTime, $n as newerHead, $r as revokesIdentity, $t as isBitcoinAddress, Aa as LEGACY_SERVICES, Ai as GROUP_REACTION_FRAME, An as cashuRequestPayload, Ar as EDIT_CAPABILITY, At as didDhtFromPublicKey, Ba as currentRelays, Bi as pairedReplyAuthor, Bn as MESH_HUBS, Br as capsDescriptors, Bt as SEPOLIA_TEST_USDT_FAUCET, C as groupWakeFrame, Ci as EDIT_RATE_WINDOW_MS, Cr as WakeLimiter, D as GROUP_READ_NOTE, Di as forwardedAgain, Dn as engineText, Dr as checkPushEndpoint, Ea as parseCallSignal, Ei as parseLinkPreview, En as engineError, Er as wakeRequest, F as mentionsMember, Fa as encodeInviteCode, Fi as reactionEmoji, Fn as parseFedimintRequestPayload, Fr as HoldRefusedError, Ft as ETHEREUM_USDT, Ga as isDiscoveryBudgetError, Gn as beaconKeys, Gt as assertWholeSats, Hi as replySnippet, Hn as meshHubs, Ht as USDT_PUBLIC_RPC, I as groupName, Ii as reactionIsNewer, In as GhostLink, Ir as newMailbox, It as EVM_TEST_CHAINS, Ji as checkStatusCard, Jn as freshHubs, Jr as emptyIdentityLedger, Jt as walletNetworkOf, Ka as withRequestOptions, Ki as STATUS_CARD_LIMITS, Kn as beaconRecords, Kr as IdentityExchange, Kt as formatPaymentAmount, La as inviteOwnership, Li as readReaction, Ln as INVITE_TAKEN, Lr as readManifest, Lt as ONCHAIN_PROVIDER, M as GROUP_EDIT_TEXT_BYTES, Ma as OwnInviteError, Mi as ReactionWindow, Mn as findEndpoint, Mr as HOLD_DATED_BACK_MS, Mt as encodeDidDhtPacket, N as carryMentions, Na as createChatInvite, Ni as nextReactionNumber, Nn as isFederationId, Nr as HOLD_LIMITS, O as GroupSession, Oa as emptyLinkRecords, Oi as readForwarded, On as decodeBolt11, Or as vapidKeysMatch, P as parseCommunityEdit, Pa as decodeInviteCode, Pi as queueReaction, Pn as parseCashuRequestPayload, Pr as HoldKeys, Pt as signDidDhtPacket, Qi as claimedTime, Qn as mergeLobby, Qr as receivedIdentityStatus, Qt as sparkInvoiceDetails, Ra as DEFAULT_RELAYS, Ri as validReactionNumber, Rn as LIVENESS_PING_MS, Rr as CapsExchange, Rt as PaymentPreflightError, S as GroupWakeLimiter, Si as EDIT_BUFFER_MS, Sr as WAKE_CALL_INTERVAL_MS, T as parseGroupWakeFrame, Ti as dhtEditId, Tr as relayRequest, Ua as traceLink, Ui as BUTTON_ID, Un as pickMeshHubs, Ut as WALLET_NETWORKS, Va as normalizeRelayUrl, Vi as readReply, Vn as mayBeHub, Vr as dialDescriptors, Vt as TEST_USDT_FAUCET_AMOUNT, Wa as budgetRetryMs, Wn as COMMUNITY_TOPOLOGY, Wr as IDENTITY_REVOCATION_LABEL, Wt as assertTokenUnits, Xi as statusCardText, Xn as lobbyRecords, Xr as identityStatement, Xt as SPARK_PROVIDER, Ya as createRelayPayload, Yi as sameButtonText, Yn as lobbyKeys, Yr as identityRevocationValue, Yt as SPARK_NETWORKS, Zi as arrivalKey, Zn as mergeBeacon, Zr as newIdentityBinding, Zt as sparkAddressKind, _ as knockIdentity, _a as decodeControl, _i as parseVoiceMeta, _r as mayPin, a as sealGroupTyping, aa as rosterHas, ai as automaticTransport, ao as bytesEqual, ar as shouldBeHub, b as readKnocks, ba as RTC_CONFIG, bi as DHT_MESSAGE_TTL, br as pinNumberHolds, c as GROUP_READ_NOTE_COMMUNITY, ca as DirectPathWatch, ci as parseImageMeta, co as toBase64Url, cr as transferEnded, d as decodeCommunityLink, da as presenceSeenAt, do as utf8Encode, ea as receivedTimestamp, ei as lastSharedWithMe, eo as identityFromSeed, er as pickHubs, f as encodeCommunityLink, fa as GhostlyHttpError, fr as TypingSender, g as entryParams, ga as LIMITS, gi as fileMessageText, gr as PIN_LIMITS, h as encodeGroupEntryLink, ha as webLocalFetch, i as openGroupTyping, ia as MEMBER_KEY, ii as TRANSPORTS, io as sanitizeAvatar, ir as readLobby, ja as serviceIdFromName, ji as REACTION_LIMITS, jn as fedimintRequestPayload, jr as HOLD_CAPABILITY, jt as encodeDidDhtDeactivated, k as groupMessageId, ka as HTTP_SERVICE_PROTO, ki as COMMUNITY_REACTION_FRAME, kn as ENDPOINT, kt as didDhtDocument, l as communityHasFrame, lo as toZ32, lr as transferStalled, m as decodeGroupEntryLink, ma as parseLocalTarget, mr as typingActivity, n as GroupTypingBoard, na as GROUP_MEMBER_CAP, ni as emptyProofLedger, no as publicKeyFromZ32, nr as readBeacon, nt as isAtprotoDid, o as COMMUNITY_LIMITS, oa as verifyCommitSignature, oi as irohDescriptor, oo as fromBase64Url, or as ChatFiles, pa as formatLocalTarget, qa as PacketTooLargeError, qn as doorHubs, qt as validatePaymentTarget, r as groupTypingEpoch, ri as validExternalKey, rr as readBeaconHead, rt as normalizeAtprotoHandle, s as CommunitySession, sa as edgeParams, si as irohRelayUrl, so as randomBytes, sr as FILE_LIMITS, ta as shownTime, ti as PeerProofs, tn as isPubkyKey, to as identityFromSeedB64, tr as rankHubs, u as communityMessageId, ua as RELAY_POLL_INTERVALS, ui as safeBlobType, uo as utf8Decode, v as knockRecords, va as encodeControl, vr as nextPinNumber, w as groupWakes, wi as RateWindow, wr as newWakeToken, xi as peekDhtMailbox, xr as readPin, y as mergeKnocks, yi as parseVideoMeta, yr as pinIsNewer, za as RelayTransport, zi as wireReaction, zn as pairedMessageFrame, zr as DHT_TEXT_CAPABILITY, zt as SEPOLIA_TEST_USDT } from "./src-7sdQpCoi.js";
+import { a as deleteDatabase, c as profileOpenFailure, d as wrap, i as databaseName, l as store, n as STORES, o as fileStore, r as clearProfileStores, s as openDb, t as CARD_INDEX, u as transact } from "./idb-DIN_Miwb.js";
+import { $ as boundedIdentityFetch, A as TEST_MINT, B as registeredLightningProviders, C as networkLabel, D as WALLET_TYPES, F as paysItsOwnInvoices, G as SourceConfigError, H as reserveAdapterIds, I as BACKUP_MEDIA_TYPE, J as networkMode, K as SourceUnreachableError, L as MAX_BACKUP_BYTES, M as isTestMint, N as isWorthlessMint, O as BITCOIN_INVOICE_ON_TESTNET, P as mintNetwork, Q as setOwnDidSource, R as identityProviders, S as WrongNetworkError, T as cashuMint, U as NothingSpentError, V as registeredOnchainProviders, W as PROVIDER_PLATFORMS, X as assertPublicServer, Y as redact, Z as resolveAtprotoDid, _ as newDeviceKey, a as createFailure, at as replyRef, b as ModeChanged, c as paymentNetwork, ct as paymentWireId, d as networkReason, dt as removeStored, et as verifyIdentity, f as rpcHost, ft as storedSize, g as intentRepository, h as ProviderSources, i as assertConfirmedReal, it as receivedPairedReply, j as fakesLightning, k as DEFAULT_MINTS, l as paymentNetworksOf, lt as FileAppender, m as LightningCards, n as loadFedimintSdk, nt as groupReply, o as createTiming, ot as replyTo, p as CASHU_CARD, pt as streamStored, q as isNothingSpentError, r as WALLET_NAMES, rt as pairedWireReply, s as crossNetwork, st as paymentAlias, t as fedimintDatabase, tt as chosenResolver, u as walletInstances, ut as readStored, v as sealSeed, w as CASHU_MINT_SOURCE, x as ModeGate, y as unsealSeed, z as onAdaptersChanged } from "../ghostly.mjs";
 import { base64, base64url, base64urlnopad, bech32, hex } from "@scure/base";
 import { hkdf } from "@noble/hashes/hkdf.js";
 import { sha256 } from "@noble/hashes/sha2.js";
@@ -12,11 +15,112 @@ import WalletManagerEvm from "@tetherto/wdk-wallet-evm";
 import { Interface, Transaction, getAddress, keccak256 } from "ethers";
 import { ArkAddress, EsploraProvider, IndexedDBContractRepository, IndexedDBWalletRepository, MnemonicIdentity, RestArkProvider, RestIndexerProvider, Transaction as Transaction$1, Wallet, assertAllowedSighashTypes, assertSubmittedArkTxid, canRecoverOnchain, isRecoverable, matchServerCheckpoints, verifyTapscriptSignatures } from "@arkade-os/sdk";
 import { tapLeafHash } from "@scure/btc-signer/payment.js";
+import { Amount, MeltChangeError, OutputData, Wallet as Wallet$1, decodePaymentRequest, deserializeSwapPreview, getEncodedToken, getTokenMetadata, isMintOperationError, serializeSwapPreview } from "@cashu/cashu-ts";
 import { Transaction as Transaction$2 } from "@scure/btc-signer";
 import { bytesToHex, concatBytes, hexToBytes, utf8ToBytes } from "@noble/hashes/utils.js";
 import * as nip04 from "nostr-tools/nip04";
 import * as nip44 from "nostr-tools/nip44";
-import { Amount, MeltChangeError, OutputData, Wallet as Wallet$1, decodePaymentRequest, deserializeSwapPreview, getEncodedToken, getTokenMetadata, isMintOperationError, serializeSwapPreview } from "@cashu/cashu-ts";
+/** Evidence older than this says nothing about the clock now. */
+var CLOCK_EVIDENCE_MS = 18e5;
+/** Sources kept of each kind: a profile has a few relays, and may have hundreds of contacts. */
+var KEPT = 64;
+/** -1: everything the sample allows is behind by more than `CLOCK_OFF_MS`; 1: ahead; 0: it does not say. */
+var says = (sample) => sample.low > 6e4 ? 1 : sample.high < -6e4 ? -1 : 0;
+var middle = (values) => {
+	const sorted = [...values].sort((a, b) => a - b);
+	return sorted[Math.floor((sorted.length - 1) / 2)];
+};
+/**
+* The rule alone: how far this clock is from the others' (ms, positive when it is ahead) when the samples fresh at
+* `now` say it is clearly off, else null.
+*/
+function clockOffset(servers, peers, now) {
+	const fresh = (samples) => [...samples.values()].filter((s) => now - s.at < CLOCK_EVIDENCE_MS);
+	const s = fresh(servers), p = fresh(peers);
+	const mid = (sample) => (sample.low + sample.high) / 2;
+	for (const way of [1, -1]) {
+		const serversOff = s.filter((x) => says(x) === way), peersOff = p.filter((x) => says(x) === way);
+		const serversNot = s.length - serversOff.length, peersNot = p.length - peersOff.length;
+		if (serversOff.length >= 2 && serversNot === 0) return Math.round(middle(serversOff.map(mid)));
+		if (serversNot > 0) continue;
+		if (serversOff.length === 1 && peersOff.length >= 1 && peersNot === 0) return Math.round(middle([...serversOff, ...peersOff].map(mid)));
+		if (peersOff.length >= 3 && peersOff.length >= 3 * peersNot) return Math.round(middle(peersOff.map(mid)));
+	}
+	return null;
+}
+var ClockWatch = class {
+	onChange;
+	now;
+	servers = /* @__PURE__ */ new Map();
+	peers = /* @__PURE__ */ new Map();
+	was = null;
+	timer = null;
+	/** `onChange`: what `offset` says changed (it appeared, went away, or moved by a minute). */
+	constructor(onChange = () => {}, now = Date.now) {
+		this.onChange = onChange;
+		this.now = now;
+	}
+	/**
+	* A server's time: `date` (ms, to the second) from an answer to a request that went out at `sent` and came back at
+	* `received`, both by this clock.
+	*/
+	server(source, date, sent, received) {
+		if (!Number.isFinite(date) || date <= 0 || received < sent) return;
+		this.keep(this.servers, source, {
+			low: sent - date - 999,
+			high: received - date,
+			at: this.now()
+		});
+	}
+	/**
+	* A contact's packet, dated `packetAt` by its clock, that came between this device's reads of its record at
+	* `readBefore` and `readAt` (this clock). Says nothing when the two reads were far apart.
+	*/
+	peer(peer, packetAt, readBefore, readAt) {
+		if (!(readBefore > 0) || readAt < readBefore || readAt - readBefore > 15e3 || !Number.isFinite(packetAt)) return;
+		this.keep(this.peers, peer, {
+			low: readBefore - packetAt,
+			high: readAt - packetAt,
+			at: this.now()
+		});
+	}
+	keep(samples, source, sample) {
+		samples.delete(source);
+		samples.set(source, sample);
+		if (samples.size > KEPT) samples.delete(samples.keys().next().value);
+		this.settle();
+	}
+	/** This clock minus the others', in ms (positive: ahead), when it is clearly off; else null. */
+	get offset() {
+		return clockOffset(this.servers, this.peers, this.now());
+	}
+	/** The clock was set, or the evidence is of another time: nothing is known until the next answers. */
+	reset() {
+		this.servers.clear();
+		this.peers.clear();
+		this.settle();
+	}
+	/** Stops the timer that lets the evidence age out. */
+	close() {
+		if (this.timer) clearTimeout(this.timer);
+		this.timer = null;
+	}
+	settle() {
+		this.close();
+		for (const samples of [this.servers, this.peers]) for (const [source, sample] of samples) if (this.now() - sample.at >= 18e5) samples.delete(source);
+		const offset = this.offset;
+		if (offset !== null) {
+			const oldest = Math.min(...[...this.servers.values(), ...this.peers.values()].map((s) => s.at));
+			this.timer = setTimeout(() => this.settle(), Math.max(1e3, oldest + CLOCK_EVIDENCE_MS - this.now()));
+			this.timer.unref?.();
+		}
+		const reads = (value) => value === null ? null : Math.round(value / 6e4);
+		if (reads(offset) === reads(this.was)) return;
+		this.was = offset;
+		this.onChange(offset);
+	}
+};
+//#endregion
 //#region ../browser/src/engine/paymentAdapters/walletNetworks.ts
 /** Where the wallet of one network is stored. The same key an older app parks it under, so it finds it too. */
 var walletKey = (rail, network) => `${rail}-mode-${network}`;
@@ -3960,26 +4064,59 @@ var CashuAdapter = class {
 			token = await this.wallet.executeReviewedCashu(review, prepared);
 		} catch (error) {
 			prepared.attemptEndedAt = Date.now();
+			if (persist && isMintOperationError(error) && await this.wallet.reviewedCashuSpentElsewhere(prepared).catch(() => false)) return this.spentElsewhere(prepared, persist);
 			throw error;
 		}
 		await persist?.();
 		await this.publish(review, token);
-		return { settled: await this.wallet.reviewedCashuSpent(prepared) };
+		return await this.outcome(review, prepared) ?? { settled: false };
+	}
+	/**
+	* What the mint and this wallet know of a payment whose token went out: paid once the mint reads its ecash spent,
+	* unless this wallet is the one that spent it, taking the payment back. Asked in that order: ecash taken back while
+	* the mint was being asked reads spent too. Undefined while the contact has not taken it.
+	*/
+	async outcome(review, prepared) {
+		const spent = await this.wallet.reviewedCashuSpent(prepared);
+		if (await this.wallet.reviewedCashuTakenBack(review.id)) return {
+			settled: false,
+			failed: true,
+			error: engineText("paymentTakenBack")
+		};
+		return spent ? { settled: true } : void 0;
 	}
 	/** `persist` saves the intent as it is: required, since the abandon path must be durable before it releases anything. */
 	async reconcile(review, prepared, persist) {
 		if (prepared.abandoned) return this.abandon(prepared, persist);
-		if (await this.wallet.reviewedCashuSpent(prepared)) return { settled: true };
+		if (prepared.spentElsewhere) return this.spentElsewhere(prepared, persist);
+		const known = await this.outcome(review, prepared);
+		if (known) return known;
 		const token = prepared.token ?? await this.wallet.recoverReviewedCashu(review, prepared);
 		if (token) await this.publish(review, token);
-		if (await this.wallet.reviewedCashuSpent(prepared)) return { settled: true };
+		const after = await this.outcome(review, prepared);
+		if (after) return after;
 		if (!token && Date.now() >= swapSettledAt(review, prepared) && await this.wallet.reviewedCashuNeverSwapped(prepared)) return this.abandon(prepared, persist);
+		if (!token && await this.wallet.reviewedCashuSpentElsewhere(prepared)) return this.spentElsewhere(prepared, persist);
 		return { settled: false };
 	}
 	/**
 	* The mint proved this swap never happened. Marked for good first (a reload repeats only this), then its reserved
 	* inputs are released. Nothing sends the saved swap again: approve claims pending reviews only, and reconcile asks.
 	*/
+	/**
+	* The ecash this payment was to spend is spent, and not by this payment. Marked for good first, then the wallet lets
+	* go of what the mint reads spent, frees the rest, and asks the mint about its other ecash there.
+	*/
+	async spentElsewhere(prepared, persist) {
+		prepared.spentElsewhere = true;
+		await persist();
+		await this.wallet.dropReviewedCashu(prepared);
+		return {
+			settled: false,
+			failed: true,
+			error: engineText("reviewedEcashSpent")
+		};
+	}
 	async abandon(prepared, persist) {
 		prepared.abandoned = true;
 		await persist();
@@ -4146,7 +4283,15 @@ var BitcoinService = class {
 				failed: true,
 				error: "Another transaction spent these coins: this payment can never confirm"
 			};
-			if (status.state === "missing") await provider.broadcast(prepared).catch(() => {});
+			if (status.state === "missing") {
+				if (!review.submittedAt) return {
+					txid: prepared.txid,
+					settled: false,
+					failed: true,
+					error: "This payment was never approved: nothing was sent"
+				};
+				await provider.broadcast(prepared).catch(() => {});
+			}
 			return {
 				txid: prepared.txid,
 				settled: false,
@@ -11407,6 +11552,7 @@ function composeDetails(message, around) {
 			linkId: message.linkId,
 			sender: message.sender,
 			timestamp: message.timestamp,
+			...message.sentAt !== void 0 && { sentAt: message.sentAt },
 			via: message.via,
 			delivery: message.delivery,
 			deliveryError: message.deliveryError,
@@ -11530,6 +11676,7 @@ var FileDesk = class {
 		if (chat) return chat;
 		const made = {
 			local: /* @__PURE__ */ new Map(),
+			places: /* @__PURE__ */ new Map(),
 			saving: Promise.resolve(),
 			lastSaved: /* @__PURE__ */ new Map(),
 			files: void 0
@@ -11569,7 +11716,13 @@ var FileDesk = class {
 		this.deps.changed();
 	}
 	handle(linkId, frame) {
-		return this.chat(linkId).files.handle(frame);
+		const chat = this.chat(linkId);
+		const id = frame.t === "pf-offer" && typeof frame.id === "string" ? frame.id : void 0;
+		if (id === void 0 || !this.deps.place || chat.local.has(id) || chat.places.has(id)) return chat.files.handle(frame);
+		chat.places.set(id, this.deps.place(linkId));
+		return chat.files.handle(frame).finally(() => {
+			if (!chat.local.has(id)) chat.places.delete(id);
+		});
 	}
 	/** Whether files/3 is live in this chat, and what the contact said it can take. */
 	status(linkId) {
@@ -11579,6 +11732,11 @@ var FileDesk = class {
 			peerRoom: files?.peerRoom ?? null
 		};
 	}
+	/** A files/3 transfer of this chat's under way on its session: offered, moving, or being checked. */
+	moving(linkId) {
+		const files = this.chats.get(linkId)?.files;
+		return !!files?.live && files.records().some((r) => r.state === "offered" || r.state === "active" || r.state === "verifying");
+	}
 	/**
 	* Offers a file whose record and bytes are stored under its local id (`outgoingFileId`). Offered before (Retry, a
 	* restart): an unfinished transfer is taken over and offered again, a failed one sent again; never a second one.
@@ -11792,6 +11950,8 @@ var FileDesk = class {
 				...file.video && { video: file.video },
 				...file.image && { image: file.image }
 			};
+			const place = chat.places.get(record.id), sentAt = claimedTime(file.timestamp);
+			chat.places.delete(record.id);
 			chat.saving = chat.saving.then(async () => {
 				await fileStore.put({
 					id,
@@ -11816,9 +11976,12 @@ var FileDesk = class {
 					id: `peer_${record.id}`,
 					text: fileMessageText(message),
 					sender: "peer",
-					timestamp: file.timestamp,
 					via: "datalink",
 					file: message,
+					...place !== void 0 && sentAt !== void 0 ? {
+						timestamp: place,
+						sentAt
+					} : { timestamp: file.timestamp },
 					...file.reply && { replyTo: receivedPairedReply(file.reply) },
 					...file.forwarded && { forwarded: file.forwarded },
 					details: { wire: fileWire("files/3", file.size) }
@@ -12234,7 +12397,7 @@ function takesPeerEdit(message, text) {
 function withEdit(message, edit) {
 	const before = message.edit?.history ?? [];
 	const history = edit.text === message.text || edit.card && edit.card.kind !== "buttons" ? before : trimHistory([...before, {
-		at: message.edit?.at ?? message.timestamp,
+		at: message.edit?.at ?? shownTime(message),
 		text: message.text
 	}]);
 	const next = {
@@ -12281,9 +12444,32 @@ var RESEND_POLICY = {
 	/** Queued this long with the contact away, it is handed to store-and-forward when the chat allows it. */
 	holdAfterMs: 6e4
 };
+/** How long one turn of an outbox may hold the next one back: a send that never returns must not stop the chat. */
+var TURN_MS = 3e4;
+/**
+* A text of mine, not handed to store-and-forward, and still to go: queued, or waiting for the chat to carry it. (A
+* file or a payment request that waits for the live session has no wire id, and its own sender.)
+*/
+var toGo = (m) => m.sender === "me" && m.via !== "hold" && !!m.wireId && (m.delivery === "queued" || m.delivery === "waiting");
+/** A file of mine that waits for the live link (its row has no wire id: the transfer has its own). */
+var waitingFile = (m) => m.sender === "me" && m.via !== "hold" && !m.wireId && !!m.file && m.delivery === "waiting";
+var oldestFirst = (a, b) => a.timestamp - b.timestamp;
 /** Durable message IDs survive retries. A lost receipt means unknown delivery, never a claim that the peer did
 * not receive the message: the receiver acknowledges a duplicate id without showing it twice, so an unconfirmed
-* message is sent again by itself while the chat can carry it, within `RESEND_POLICY`, then waits for Retry. */
+* message is sent again by itself while the chat can carry it, within `RESEND_POLICY`, then waits for Retry.
+*
+* What a chat's outbox hands its link goes oldest first. The contact's app places each message where it arrives
+* (WISP 400, requirement 10), so the order they are sent in is the order the contact reads them in, for good. A new
+* message, a link that came back, a receipt that freed the DHT path and each queued message's own timer all send, and
+* each of them took its turn while another was still between two steps: a message written later went out before one
+* written earlier, and the contact kept them that way. They now take turns (`turn`), and each turn sends what is
+* older first. Only a message the chat cannot carry (a long text while on the DHT) is passed by a later one.
+*
+* A link that closes takes its turn too (`disconnected`), and so does a receipt that never came. Both make a sent
+* message queued again, and both did it beside a look in progress: a link that dropped with a hundred texts
+* unconfirmed and came back within a second was looked at while half of them were between sent and queued, the look
+* passed those by and sent the later ones first. A look in progress when the link closes stops there: what it sent
+* on the old link may be lost, and the ones after them must not go on the new link before them. */
 var Outbox = class {
 	store;
 	send;
@@ -12295,8 +12481,18 @@ var Outbox = class {
 	waiting = /* @__PURE__ */ new Map();
 	attempts = /* @__PURE__ */ new Map();
 	busy = /* @__PURE__ */ new Set();
-	/** In flight when the chat reopened (`flush({ reopened })`): sent again on the new link once that send returns. */
+	/** Still in flight when the look a reopened chat asked for began (`flush({ reopened })`): sent again once that send returns. */
 	reopenedWhileBusy = /* @__PURE__ */ new Set();
+	/** The turns taken so far, one after the other (`turn`). */
+	line = Promise.resolve();
+	/** How many times the chat reopened, and the count each message last went out under: one sent since is on the new link. */
+	opened = 0;
+	sentUnder = /* @__PURE__ */ new Map();
+	/** How many times the link closed with something unconfirmed on it, and the count when the turn in progress began. */
+	closed = 0;
+	began = 0;
+	/** The link closed and what was unconfirmed on it is not queued again yet: the next turn does it first. */
+	dropped = false;
 	stopped = false;
 	resender;
 	policy;
@@ -12333,13 +12529,137 @@ var Outbox = class {
 			else await this.queue(message, "Not confirmed before the app closed. It is sent again, under the same ID, once your contact is reachable.");
 		}
 	}
-	/** Sends one message now. `manual`: the Retry button — a new window and a fresh count of attempts. */
-	async transmit(id, { manual = false } = {}) {
+	/**
+	* One at a time, in the order asked: `run` starts when the turns before it are over. A turn that takes longer than
+	* `TURN_MS` no longer holds the next one back.
+	*/
+	turn(run) {
+		const result = this.line.then(async () => {
+			if (this.dropped) {
+				this.dropped = false;
+				await this.requeueUnconfirmed();
+			}
+			this.began = this.closed;
+			return run();
+		});
+		this.line = new Promise((next) => {
+			const timer = setTimeout(next, TURN_MS);
+			result.then(() => {}, () => {}).then(() => {
+				clearTimeout(timer);
+				next();
+			});
+		});
+		return result;
+	}
+	/** The link has not closed since this turn began: what the turn sends goes on the link the turn looked at. */
+	get sameLink() {
+		return !this.stopped && this.closed === this.began;
+	}
+	/** A new message a turn could not send (the link closed under it, or the ones before it still wait): it waits too. */
+	async waitsItsTurn(message) {
+		await this.store.update(message.id, "waiting", "Waits for the messages before it to go.", {
+			via: "datalink",
+			resendUntil: message.resendUntil ?? this.now() + this.policy.windowMs
+		});
+		this.schedule(message.id);
+	}
+	/**
+	* Sends one message. A new one goes after the ones written before it that still wait to go: those the chat can
+	* carry go first, and if it then cannot carry this one (the DHT path took one of them), it waits its turn too.
+	* `manual`: the Retry button — it goes now, with a new window and a fresh count of attempts.
+	*/
+	transmit(id, { manual = false } = {}) {
+		return this.turn(async () => {
+			if (manual || this.stopped || this.busy.has(id) || this.receipts.has(id)) return this.transmitNow(id, { manual });
+			const messages = await this.store.read(), message = messages.find((m) => m.id === id);
+			const before = message?.delivery === "sending" ? this.before(messages, message) : [];
+			if (!before.length) return this.transmitNow(id, {}, message);
+			const passed = await this.inOrder(before);
+			if (this.stopped) return;
+			if (this.sameLink && this.resender.ready({
+				...message,
+				via: "datalink"
+			})) {
+				await this.catchUp(passed);
+				if (this.sameLink) return this.transmitNow(id);
+			}
+			if (this.stopped) return;
+			await this.waitsItsTurn(message);
+		});
+	}
+	/** The messages written before a new one that have not gone yet, oldest first. */
+	before(messages, message) {
+		const stored = (m) => m.sender === "me" && m.via !== "hold" && m.delivery === "sending" && !!m.wireId && m.timestamp < message.timestamp && !this.receipts.has(m.id) && !this.busy.has(m.id);
+		return [...this.due(messages.filter((m) => m.id !== message.id && m.timestamp <= message.timestamp)), ...messages.filter(stored)].sort(oldestFirst);
+	}
+	/**
+	* What a look at the chat takes up, oldest first: what is queued or waiting, and what was sent and still awaits its
+	* receipt when the path it took is not the one the chat has now (it went on the DHT and the chat is live: it goes on
+	* the link, before what was written after it) or when the chat reopened since (`opened`).
+	*/
+	due(messages, opened) {
+		const unconfirmed = (m) => m.sender === "me" && m.via !== "hold" && m.delivery === "sent" && this.receipts.has(m.id);
+		return messages.filter((m) => !this.busy.has(m.id) && (toGo(m) || this.file(m) || unconfirmed(m) && (opened !== void 0 && (this.sentUnder.get(m.id) ?? 0) < opened || !!this.resender.via && this.resender.via(m) !== m.via && this.resender.ready(m)))).sort(oldestFirst);
+	}
+	/**
+	* Looks at each message, oldest first: it goes if the chat can carry it. The ones the chat could not carry are
+	* handed back, and asked once more at the moment a later one is found able to go (`catchUp`): a link says it is open
+	* a moment before it carries text, and a look that began in that moment sent the later messages and left the first
+	* ones behind.
+	*/
+	/** Whether this chat's waiting files go through this outbox (`Resender.sendFile`). */
+	get sendsFiles() {
+		return !!this.resender.sendFile;
+	}
+	file(message) {
+		return this.sendsFiles && waitingFile(message);
+	}
+	/** A waiting file is said on the link, after the older messages passed by that can go now. False: the link cannot carry it. */
+	async fileGoes(message, passed) {
+		if (!this.resender.ready(message)) {
+			if (!this.waiting.get(message.id)?.timer) this.schedule(message.id);
+			return false;
+		}
+		if (passed) await this.catchUp(passed);
+		if (!this.sameLink) return true;
+		await this.resender.sendFile(message).catch(() => {});
+		this.forget(message.id);
+		return true;
+	}
+	async inOrder(messages) {
+		const passed = [];
+		for (const message of messages) {
+			if (!this.sameLink) break;
+			if (message.delivery === "sending") {
+				await this.catchUp(passed);
+				if (this.sameLink) await this.transmitNow(message.id);
+				else if (!this.stopped) await this.waitsItsTurn(message);
+				continue;
+			}
+			if (!await (this.file(message) ? this.fileGoes(message, passed) : this.again(message, passed))) passed.push(message);
+		}
+		return passed;
+	}
+	/** The messages passed by that the chat can carry by now go, oldest first; the others stay where they are. */
+	async catchUp(passed) {
+		for (let i = 0; i < passed.length && this.sameLink;) {
+			if (!this.resender.ready(passed[i])) {
+				i++;
+				continue;
+			}
+			const [older] = passed.splice(i, 1);
+			if (this.file(older)) await this.fileGoes(older);
+			else await this.attempt(older.id);
+			i = 0;
+		}
+	}
+	/** `read`: the message's row, when it was read just now with nothing awaited since. */
+	async transmitNow(id, { manual = false } = {}, read) {
 		if (this.stopped || this.busy.has(id) || this.receipts.has(id)) return;
 		this.busy.add(id);
 		let again;
 		try {
-			let message = (await this.store.read()).find((m) => m.id === id);
+			let message = read ?? (await this.store.read()).find((m) => m.id === id);
 			if (!message?.wireId || !message.delivery || message.delivery === "delivered") return;
 			const wait = this.waiting.get(id);
 			if (wait?.timer) {
@@ -12366,6 +12686,7 @@ var Outbox = class {
 				return;
 			}
 			this.track(id, typeof this.timeoutMs === "number" ? this.timeoutMs : this.timeoutMs(message));
+			this.sentUnder.set(id, this.opened);
 			const error = await this.send(message);
 			if (error) {
 				this.clear(id);
@@ -12406,25 +12727,53 @@ var Outbox = class {
 	* oldest first. `reopened`: a new link, so what still awaits a receipt from the old one, or from the DHT, goes on it too
 	* (a receipt on the link also ends the DHT's own retries).
 	*/
-	async flush({ reopened = false } = {}) {
-		if (this.stopped || !reopened && !this.waiting.size) return;
-		if (reopened) for (const id of this.busy) this.reopenedWhileBusy.add(id);
-		const due = (await this.store.read()).filter((m) => m.sender === "me" && m.via !== "hold" && !this.busy.has(m.id) && (m.delivery === "queued" || m.delivery === "waiting" || reopened && m.delivery === "sent" && this.receipts.has(m.id))).sort((a, b) => a.timestamp - b.timestamp);
-		for (const message of due) await this.again(message);
-	}
-	/** A queued or waiting message is looked at; one sent and awaiting its receipt goes again now, if the chat can carry it. */
-	async again(message) {
-		if (message.sender !== "me" || message.via === "hold") return;
-		if (message.delivery === "queued" || message.delivery === "waiting") {
-			await this.attempt(message.id);
+	flush({ reopened = false } = {}) {
+		if (this.stopped || !reopened && !this.waiting.size) return Promise.resolve();
+		const opened = reopened ? ++this.opened : void 0;
+		return this.turn(async () => {
+			if (this.stopped) return;
+			if (reopened) for (const id of this.busy) this.reopenedWhileBusy.add(id);
+			await this.inOrder(this.due(await this.store.read(), opened));
+		});
+	}
+	/** A queued message's check came due: the ones written before it that have not gone are looked at first. */
+	async check(id) {
+		if (this.stopped) return;
+		const messages = await this.store.read(), message = messages.find((m) => m.id === id);
+		if (!message || !(toGo(message) || this.file(message))) {
+			await this.attempt(id);
 			return;
 		}
-		if (message.delivery !== "sent" || !this.receipts.has(message.id)) return;
+		await this.inOrder(this.due(messages.filter((m) => m.timestamp <= message.timestamp)));
+	}
+	/**
+	* A queued or waiting message is looked at; one sent and awaiting its receipt goes again now, if the chat can carry
+	* it. False when the chat could not carry it.
+	*/
+	async again(message, passed) {
+		if (message.sender !== "me" || message.via === "hold") return true;
+		if (message.delivery === "queued" || message.delivery === "waiting") return this.attempt(message.id, passed);
+		if (message.delivery !== "sent" || !this.receipts.has(message.id)) return true;
 		this.clear(message.id);
-		if (this.resender.ready(message)) await this.transmit(message.id);
-		else await this.requeue(message.id, "Connection closed before receipt. Delivery is unconfirmed.");
+		if (this.resender.ready(message)) {
+			if (passed) await this.catchUp(passed);
+			await this.transmitNow(message.id);
+			return true;
+		}
+		await this.requeue(message.id, "Connection closed before receipt. Delivery is unconfirmed.");
+		return false;
+	}
+	/**
+	* The link closed: what awaits a receipt from it is queued again, in a turn of its own, so a look at the chat never
+	* finds a message between sent and queued. A look in progress stops (`sameLink`).
+	*/
+	disconnected() {
+		if (!this.receipts.size) return Promise.resolve();
+		this.closed++;
+		this.dropped = true;
+		return this.turn(async () => {});
 	}
-	async disconnected() {
+	async requeueUnconfirmed() {
 		const messages = await this.store.read();
 		for (const id of [...this.receipts.keys()]) {
 			if (messages.find((m) => m.id === id)?.via === "pkarr") {
@@ -12440,33 +12789,40 @@ var Outbox = class {
 		this.reopenedWhileBusy.clear();
 		for (const wait of this.waiting.values()) if (wait.timer) clearTimeout(wait.timer);
 		this.waiting.clear();
-		await this.disconnected();
+		this.dropped = false;
+		await this.requeueUnconfirmed();
 	}
-	/** Looks at one queued message: sends it if the chat can carry it, hands it to store-and-forward, or waits more. */
-	async attempt(id) {
-		if (this.stopped || this.busy.has(id)) return;
+	/**
+	* Looks at one queued message: sends it if the chat can carry it, hands it to store-and-forward, or waits more.
+	* False when the chat could not carry it and it still waits. `passed`: older messages the chat could not carry a
+	* moment ago, which go first if it can now.
+	*/
+	async attempt(id, passed) {
+		if (this.stopped || this.busy.has(id)) return true;
 		const message = (await this.store.read()).find((m) => m.id === id);
 		if (!message || message.delivery !== "queued" && message.delivery !== "waiting" || message.via === "hold") {
 			this.forget(id);
-			return;
+			return true;
 		}
 		if ((message.resendUntil ?? Infinity) <= this.now()) {
 			if (message.delivery === "waiting") {
 				this.forget(id);
 				await this.store.update(id, "failed", `Your contact was not reachable within ${days(this.policy.windowMs)}. It was not sent; Retry sends it.`);
 			} else await this.fail(id, `Not confirmed within ${days(this.policy.windowMs)}.`);
-			return;
+			return true;
 		}
 		if (this.resender.ready(message)) {
-			await this.transmit(id);
-			return;
+			if (passed) await this.catchUp(passed);
+			await this.transmitNow(id);
+			return true;
 		}
 		const wait = this.waiting.get(id);
 		if (this.resender.divert && wait && this.now() - wait.since >= this.policy.holdAfterMs && await this.resender.divert(message)) {
 			this.forget(id);
-			return;
+			return true;
 		}
 		if (!wait?.timer) this.schedule(id);
+		return false;
 	}
 	/** After a failed attempt: queued again, unless its window or its attempts are spent. */
 	async requeue(id, reason) {
@@ -12501,7 +12857,7 @@ var Outbox = class {
 		wait.timer = setTimeout(() => {
 			wait.timer = void 0;
 			wait.step++;
-			this.attempt(id).catch(() => {});
+			this.turn(() => this.check(id)).catch(() => {});
 		}, delay);
 		this.waiting.set(id, wait);
 	}
@@ -12510,17 +12866,20 @@ var Outbox = class {
 		if (wait?.timer) clearTimeout(wait.timer);
 		this.waiting.delete(id);
 		this.attempts.delete(id);
+		this.sentUnder.delete(id);
 	}
 	track(id, duration) {
 		this.clear(id);
-		this.receipts.set(id, setTimeout(() => {
-			this.receipts.delete(id);
-			(async () => {
+		const timer = setTimeout(() => {
+			this.turn(async () => {
+				if (this.receipts.get(id) !== timer) return;
+				this.receipts.delete(id);
 				const message = (await this.store.read()).find((m) => m.id === id);
 				if (message?.via === "pkarr") await this.expired(message);
 				else await this.requeue(id, "No receipt received yet.");
-			})().catch(() => {});
-		}, duration));
+			}).catch(() => {});
+		}, duration);
+		this.receipts.set(id, timer);
 	}
 	clear(id) {
 		const timer = this.receipts.get(id);
@@ -12758,7 +13117,8 @@ var ITEM = {
 	invoice: (a) => `An invoice for ${a}, not paid yet`,
 	paid: (a) => `${a} paid to an invoice, not claimed from the mint yet`,
 	unclaimed: (a) => `${a} the mint says it issued for an invoice, never received here`,
-	sent: (a) => `${a} in ecash you sent, not taken yet`
+	sent: (a) => `${a} in ecash you sent, not taken yet`,
+	swap: (a) => `${a} in an exchange with the mint, not finished yet`
 };
 var ENGLISH_REMOVAL = {
 	sats: (n, network) => `${n.toLocaleString("en-US")} ${network === "testnet" ? "test sats" : "sats"}`,
@@ -12783,8 +13143,13 @@ function items(type, network, view, words, card) {
 		...a.paymentId ? { paymentId: a.paymentId } : {}
 	});
 	const returns = (a) => a.kind === "sent" && type === "cashu";
+	const swaps = type === "cashu" && view?.openSwaps ? [{
+		kind: "swap",
+		text: words.item("swap", amount(view.swapsAmount ?? 0)),
+		amount: amount(view.swapsAmount ?? 0)
+	}] : [];
 	return {
-		awaiting: mine.filter((a) => !returns(a)).map(item),
+		awaiting: [...mine.filter((a) => !returns(a)).map(item), ...swaps],
 		returnable: mine.filter(returns).map(item)
 	};
 }
@@ -12806,7 +13171,7 @@ function walletRemoval(type, network, view, intents = [], card, words = ENGLISH_
 		case "cashu": return {
 			...base,
 			custody: "device",
-			held: known(view?.balance ?? 0),
+			held: known((view?.balance ?? 0) + (view?.setAside ?? 0)),
 			backup: "tokens",
 			pending
 		};
@@ -13281,6 +13646,16 @@ var db = {
 			want += newest.length - page.length;
 		}
 	},
+	/**
+	* Every message of this profile that carries a task or a routine card, from every chat and group, oldest first (time,
+	* then id). Reads the card index only (`CARD_INDEX`): no chat's history is read, however long. The index follows the
+	* rows, so an edit's card, a deleted message and a deleted chat or group are in step with no bookkeeping.
+	*/
+	async getCardMessages() {
+		const index = (await store(STORES.messages, "readonly")).index(CARD_INDEX);
+		const [tasks, routines] = await Promise.all([wrap(index.getAll("task")), wrap(index.getAll("routine"))]);
+		return [...tasks, ...routines].sort((a, b) => a.timestamp - b.timestamp || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+	},
 	/** Returns false when the message was already stored. */
 	async addMessage(message) {
 		const tx = (await openDb()).transaction(STORES.messages, "readwrite");
@@ -13381,6 +13756,32 @@ var db = {
 	}
 };
 //#endregion
+//#region ../browser/src/engine/arrival.ts
+/**
+* A history stored before a received row was placed where it arrived (WISP 400, requirement 10; until 2026-10): a
+* contact's row sits under the time the contact's clock said, up to five minutes ahead of this device's. Almost all of
+* it stays as it is: its stored time is its place, so nothing moves when the app updates. Only the rows whose stored
+* time has not come yet are settled, once, at the start: they are the last rows of their chat, and left there a
+* message written in the next minutes would sort above them. Each takes a place just before now, in the order they
+* were in and after everything before them, and keeps the time its sender said beside it (`sentAt`).
+*
+* Returns the rows to write, as they are now; none when nothing is ahead. Rows of mine are never touched: their time
+* is the one both sides know them by.
+*/
+function settleAhead(history, now) {
+	const ahead = history.filter((m) => m.sender === "peer" && m.sentAt === void 0 && m.timestamp > now);
+	if (!ahead.length) return [];
+	let last = history.reduce((max, m) => m.timestamp > now ? max : Math.max(max, m.timestamp), 0);
+	return ahead.map((m, i) => {
+		last = Math.max(last + 1, now - (ahead.length - i));
+		return {
+			...m,
+			timestamp: last,
+			sentAt: m.timestamp
+		};
+	});
+}
+//#endregion
 //#region ../browser/src/engine/reactions.ts
 var isGroup$1 = (chat) => chat.startsWith("group:");
 /** The row a reaction names in a chat: the id both sides know it by (`replyRef`). */
@@ -13721,6 +14122,36 @@ var HUB_GRACE_MS = 18e4;
 var REFUSED_FOR_MS$1 = 6e5;
 var ENTRY_LINGER_MS$1 = 2e4;
 var RELAYED_KEPT = 4096;
+/**
+* Someone the chain took out while its app was closed comes back believing it is a member: it asks in a hub's lobby,
+* or lists itself as a hub. A hub then keeps an edge to it for a moment, only to hand it the commit that took it out
+* (`farewell`): at most `FAREWELL_EDGES` at a time, each awaited `FAREWELL_WAIT_MS` and closed `FAREWELL_LINGER_MS`
+* after the commit went; the same key is not waited for again for a while (longer once it was told).
+*/
+var FAREWELL_EDGES = 4;
+var FAREWELL_WAIT_MS = 12e4;
+var FAREWELL_LINGER_MS = 1e4;
+var FAREWELL_RETRY_MS = 6e4;
+var FAREWELL_TOLD_MS = 6e5;
+var FAREWELL_SAY_MS = 1e4;
+/**
+* A key asking from before the commit that took it out was there and was sent that commit: not waited for. The two
+* times are two devices' clocks (the asker's, the commit's signer's), so "before" allows this much between them:
+* a returning member whose clock runs behind the admin's is told all the same.
+*/
+var FAREWELL_SKEW_MS = 3e5;
+/**
+* A hub dates its beacon entry by its own clock, and a reader judges it by its own. A hub's time closer than this to
+* what this app saw is taken as written; past it the two clocks differ, and the entry is read in this app's time
+* (`inMyTime`). Half as long again as a hub's pace: what an entry may trail a reading by, between two clocks that agree.
+*/
+var HUB_CLOCK_SLACK_MS = COMMUNITY_TOPOLOGY.beaconEveryMs * 1.5;
+/** Two readings of the beacon no further apart than this say when an entry that moved between them was written. */
+var HUB_CLOCK_READ_GAP_MS = 45e3;
+/** A hub's clock is remembered this long after its entry was last in the beacon. */
+var HUB_CLOCK_KEPT_MS = 6e5;
+/** A member that opens the group's link again knocks to check it is still in, this long at most (`joinByLink`). */
+var CHECK_MS = 18e4;
 var MESSAGE_LINK$1 = (groupId) => `group:${groupId}`;
 /**
 * A member key for a joiner whose entry session the member's side dials. Of a paired session's two
@@ -13752,6 +14183,8 @@ var Communities = class {
 	/** Joiners: groups whose knock is out (published), and the knock record it is in. */
 	knocked = /* @__PURE__ */ new Set();
 	knockAt = /* @__PURE__ */ new Map();
+	/** Joiners: how many others had a knock still being refreshed in the record I last read (they wait with me). */
+	knockingWith = /* @__PURE__ */ new Map();
 	/** My frames an edge took, and which of them carry an edit (`frame id → editKey`). */
 	frames = new FramesTaken();
 	carriers = /* @__PURE__ */ new Map();
@@ -13787,7 +14220,8 @@ var Communities = class {
 	}
 	/** Is this device a hub of the group? (tests and the load harness) */
 	isHub(groupId) {
-		return !!this.live.get(groupId)?.hub;
+		const live = this.live.get(groupId);
+		return !!live?.hub && live.session.status === "active";
 	}
 	async load(groups) {
 		for (const group of groups) {
@@ -13796,9 +14230,11 @@ var Communities = class {
 			const history = await this.store.getMessages(MESSAGE_LINK$1(group.id)), said = history.filter((m) => !m.event && !m.groupPay);
 			const last = said[said.length - 1], lastPeer = [...said].reverse().find((m) => m.sender !== "me");
 			if (last) this.lastMessageAt.set(group.id, last.timestamp);
-			if (lastPeer) this.lastPeerMessageAt.set(group.id, lastPeer.timestamp);
+			const peerAt = cameOrWritten(lastPeer?.timestamp, lastPeer ? group.came?.peer : void 0);
+			if (peerAt) this.lastPeerMessageAt.set(group.id, peerAt);
 			const mention = [...history].reverse().find((m) => m.mentioned);
-			if (mention) this.lastMentionAt.set(group.id, mention.timestamp);
+			const mentionAt = cameOrWritten(mention?.timestamp, mention ? group.came?.mention : void 0);
+			if (mentionAt) this.lastMentionAt.set(group.id, mentionAt);
 			for (const [, linkId] of this.host.entries(group.id)) if (group.joining?.linkId !== linkId) await this.host.closeEdge(linkId);
 			const live = this.live.get(group.id);
 			if (live) for (const key of this.host.edges(group.id).keys()) live.restored.set(key, 0);
@@ -13821,7 +14257,7 @@ var Communities = class {
 				invited: [],
 				memberLinks: {}
 			};
-			if (group.joining && (!live || live.session.status === "lost")) return [{
+			if (this.knocking(group, live)) return [{
 				...base,
 				name: groupName(group.joining.name) ?? live?.session.name ?? "",
 				isAdmin: false,
@@ -13834,7 +14270,8 @@ var Communities = class {
 					members: 0,
 					accepted: true,
 					viaLink: true,
-					stage: this.joinStage(group)
+					stage: this.joinStage(group),
+					...this.knockingWith.get(group.id) ? { waiting: this.knockingWith.get(group.id) } : {}
 				}
 			}];
 			if (!live) return [];
@@ -13843,7 +14280,7 @@ var Communities = class {
 				const id = edges.get(key);
 				return !!id && this.host.linkReady(id, 2);
 			};
-			const hubs = freshHubs(live.beacon, this.now()).map((h) => h.key);
+			const hubs = freshHubs(this.hubs(live), this.now()).map((h) => h.key);
 			return [{
 				...base,
 				name: s.name,
@@ -13904,17 +14341,36 @@ var Communities = class {
 		if (!link) throw new Error("This is not a link to a group");
 		const existing = this.stored.get(link.g);
 		const live = this.live.get(link.g);
-		if (live && live.session.status === "active") return link.g;
 		if (existing?.joining && existing.joining.host === link.host) return link.g;
+		if (live) {
+			const s = live.session;
+			if (s.status === "active" && s.roster.length === 1) return link.g;
+			if (s.status === "active") {
+				await this.startJoining(link, s.state.seedB64, this.now(), true);
+				return link.g;
+			}
+			if (s.status === "removed" || s.status === "lost") {
+				await this.startJoining(link, s.state.seedB64, this.now());
+				return link.g;
+			}
+		}
 		if (existing) await this.forget(link.g);
 		await this.startJoining(link, dialedKey(link), this.now());
 		return link.g;
 	}
-	async startJoining(link, seedB64, since) {
+	/** Knocking to get in: a joiner, or someone who was in (removed, or its admission lost) asking again. Not a member checking it still is. */
+	knocking(group, live) {
+		return !!group.joining && (!live || live.session.status !== "active");
+	}
+	/** `check`: a member, as far as this device knows, asking the door whether it still is (`joinByLink`). */
+	async startJoining(link, seedB64, since, check = false) {
 		this.lastKnock.delete(link.g);
 		this.knocked.delete(link.g);
 		this.knockAt.delete(link.g);
+		this.knockingWith.delete(link.g);
+		const before = this.stored.get(link.g)?.joining;
 		const linkId = await this.host.openEntry(link, "guest", seedB64, link.host);
+		if (before && before.linkId !== linkId) await this.host.closeEdge(before.linkId);
 		const group = this.stored.get(link.g) ?? {
 			id: link.g,
 			createdAt: since
@@ -13927,7 +14383,8 @@ var Communities = class {
 			name: group.community?.name ?? "",
 			inviter: "",
 			pieces: [],
-			since
+			since,
+			...check && { check: true }
 		};
 		this.stored.set(link.g, group);
 		await this.store.putGroup(group);
@@ -13935,9 +14392,29 @@ var Communities = class {
 		traceJoin(link.g, "join.start");
 		this.knock(group, since).catch(() => {});
 	}
+	/** The check is over (answered, or nobody was at the door): the group stays as it is here. */
+	async endCheck(group) {
+		const joining = group.joining;
+		if (!joining) return;
+		delete group.joining;
+		this.lastKnock.delete(group.id);
+		this.knocked.delete(group.id);
+		this.knockAt.delete(group.id);
+		this.knockingWith.delete(group.id);
+		await this.host.closeEdge(joining.linkId);
+		await this.store.putGroup(group);
+		this.host.emit();
+	}
 	async send(groupId, text, mentions = [], reply, forwarded, card) {
 		const live = this.live.get(groupId);
-		if (!live) return { error: "You are not in this group yet" };
+		if (!live) return {
+			error: "You are not in this group yet",
+			refused: true
+		};
+		if (!live.session.isMember) return {
+			error: live.session.state.statusReason ?? "You are not in this group",
+			refused: true
+		};
 		const result = card ? await live.session.sendText(text, this.host.myNick?.(), Date.now(), mentions, reply, forwarded, card) : await live.session.sendText(text, this.host.myNick?.(), Date.now(), mentions, reply, forwarded);
 		return "error" in result ? { error: result.error } : {
 			error: null,
@@ -14050,7 +14527,7 @@ var Communities = class {
 	*/
 	async decline(groupId) {
 		const group = this.stored.get(groupId), live = this.live.get(groupId);
-		if (!group?.joining || live && live.session.status !== "lost") throw new Error("No invitation to decline");
+		if (!group || !this.knocking(group, live)) throw new Error("No invitation to decline");
 		if (live) throw new Error("You were in this group: leave it to stop trying to get back in");
 		await this.forget(groupId);
 	}
@@ -14062,6 +14539,7 @@ var Communities = class {
 		this.lastMessageAt.delete(groupId);
 		this.lastPeerMessageAt.delete(groupId);
 		this.lastMentionAt.delete(groupId);
+		this.knockingWith.delete(groupId);
 		for (const linkId of [...this.host.edges(groupId).values(), ...this.host.entries(groupId).values()]) await this.host.closeEdge(linkId);
 		await this.store.deleteGroup(groupId);
 		this.host.historyGone?.(groupId);
@@ -14077,15 +14555,17 @@ var Communities = class {
 		this.time = now;
 		for (const group of [...this.stored.values()]) {
 			const live = this.live.get(group.id);
-			if (group.joining && (!live || live.session.status === "lost")) {
-				const every = now - group.joining.since > this.timings.patienceMs ? this.timings.slowKnockMs : this.timings.knockMs;
-				if (!this.host.linkReady(group.joining.linkId, 2) && !this.host.linkSeen?.(group.joining.linkId) && now - (this.lastKnock.get(group.id) ?? 0) >= every) await this.knock(group, now).catch(() => {});
+			if (group.joining && (this.knocking(group, live) || group.joining.check)) {
+				const waited = now - group.joining.since, every = waited > this.timings.patienceMs ? this.timings.slowKnockMs : this.timings.knockMs;
+				if (!this.knocking(group, live) && waited > CHECK_MS) await this.endCheck(group);
+				else if (!this.host.linkReady(group.joining.linkId, 2) && !this.host.linkSeen?.(group.joining.linkId) && now - (this.lastKnock.get(group.id) ?? 0) >= every) await this.knock(group, now).catch(() => {});
 				if (!live) continue;
 			}
 			if (!live) continue;
 			if (live.session.status === "lost" && !group.joining) {
 				if (live.hub) {
 					live.hub = false;
+					live.leaving = 0;
 					await this.publishBeacon(group.id, live, now, false).catch(() => {});
 				}
 				await this.closeEntries(group.id);
@@ -14096,6 +14576,12 @@ var Communities = class {
 				continue;
 			}
 			if (live.session.status !== "active") {
+				if (live.hub) {
+					live.hub = false;
+					await this.closeEntries(group.id);
+					await this.publishBeacon(group.id, live, now, false).catch(() => {});
+				}
+				live.farewells.clear();
 				await this.reconcile(group.id, live, now);
 				continue;
 			}
@@ -14111,14 +14597,19 @@ var Communities = class {
 			live.lingering.delete(linkId);
 			if ([...this.host.entries(groupId).values()].includes(linkId)) await this.host.closeEdge(linkId);
 		}
-		const alone = live.hub && !freshHubs(live.beacon, now).some((h) => h.key !== me);
-		if (now - live.lastBeaconRead >= (alone ? COMMUNITY_TOPOLOGY.beaconEveryMs : this.timings.beaconReadMs) || live.lastBeaconRead === 0) await this.readBeacon(groupId, live, now);
-		const others = freshHubs(live.beacon, now).filter((h) => h.key !== me);
+		const alone = live.hub && !freshHubs(this.hubs(live), now).some((h) => h.key !== me);
+		if ((live.beaconFailedAt ? now - live.beaconFailedAt >= BEACON_RETRY_MS : now - live.lastBeaconRead >= (alone ? COMMUNITY_TOPOLOGY.beaconEveryMs : this.timings.beaconReadMs)) || live.lastBeaconRead === 0) await this.readBeacon(groupId, live, now);
+		if (!live.beaconKnown) {
+			await this.keepLooking(groupId, live, now);
+			await this.reconcile(groupId, live, now);
+			return;
+		}
+		const others = freshHubs(this.hubs(live), now).filter((h) => h.key !== me);
 		if (!live.hub) {
-			const settled = () => now - live.joinedAt >= this.timings.newcomerMs || !freshHubs(live.beacon, now).some((h) => h.key !== me);
-			const want = () => settled() && (shouldBeHub(me, live.beacon, now) || !!live.forceHub && freshHubs(live.beacon, now).length < COMMUNITY_TOPOLOGY.maxHubs) && this.capacity(groupId, live, now) > 0;
+			const settled = () => now - live.joinedAt >= this.timings.newcomerMs || !freshHubs(this.hubs(live), now).some((h) => h.key !== me);
+			const want = () => settled() && (shouldBeHub(me, this.hubs(live), now) || !!live.forceHub && freshHubs(this.hubs(live), now).length < COMMUNITY_TOPOLOGY.maxHubs) && this.capacity(groupId, live, now) > 0;
 			if (want()) {
-				if (!live.hubCandidateAt) live.hubCandidateAt = now + (freshHubs(live.beacon, now).length ? Math.floor(this.random() * this.timings.hubJitterMs) : 0);
+				if (!live.hubCandidateAt) live.hubCandidateAt = now + (freshHubs(this.hubs(live), now).length ? Math.floor(this.random() * this.timings.hubJitterMs) : 0);
 				if (now >= live.hubCandidateAt) {
 					live.hubCandidateAt = 0;
 					if (live.lastBeaconRead !== now) await this.readBeacon(groupId, live, now);
@@ -14127,6 +14618,7 @@ var Communities = class {
 						live.hub = true;
 						live.hubSince = now;
 						live.emptySince = now;
+						live.leaving = 0;
 						live.knocksScanned = false;
 						await this.publishBeacon(groupId, live, now, true).catch(() => {});
 						traceJoin(groupId, "hub.elected");
@@ -14137,15 +14629,45 @@ var Communities = class {
 		if (live.hub) {
 			const load = this.hubLoad(groupId, live, now);
 			if (load > 0) live.emptySince = now;
-			const linkedToHub = [...this.host.edges(groupId)].some(([key, id]) => this.peerIsHub(live, key) && this.host.linkReady(id, 2));
-			if (now - live.emptySince > this.timings.idleHubMs && others.length >= COMMUNITY_TOPOLOGY.minHubs && now - live.hubSince > this.timings.idleHubMs && linkedToHub) {
-				live.hub = false;
-				await this.closeEntries(groupId);
-				await this.publishBeacon(groupId, live, now, false);
-			} else if (now - live.lastBeaconTry < BEACON_RETRY_MS) {} else if (now - live.lastBeaconWrite >= COMMUNITY_TOPOLOGY.beaconEveryMs || !live.beacon.some((h) => h.key === me) || now - live.lastBeaconWrite >= 5e3 && Math.abs(this.beaconLoad(groupId, live, now) - (live.beacon.find((h) => h.key === me)?.load ?? load)) >= 8) await this.publishBeacon(groupId, live, now, true).catch(() => {});
+			const idle = now - live.emptySince > this.timings.idleHubMs && now - live.hubSince > this.timings.idleHubMs;
+			if (live.leaving) {
+				const read = live.beaconAt > live.leaving, listed = live.beacon.some((h) => h.key === me);
+				if (read && idle && !listed && this.canStepDown(groupId, live, now)) {
+					live.leaving = 0;
+					live.hub = false;
+					const edges = this.host.edges(groupId);
+					live.myHubs = freshHubs(this.hubs(live), now).map((h) => h.key).filter((key) => {
+						const id = edges.get(key);
+						return key !== me && !!id && this.host.linkReady(id, 2);
+					}).slice(0, COMMUNITY_TOPOLOGY.hubsPerMember);
+					for (const key of live.myHubs) {
+						live.hubsAvoided.delete(key);
+						live.hubWaits.delete(key);
+						live.hubsUp.add(key);
+					}
+					live.members.clear();
+				} else if (read && idle && listed && this.canStepDown(groupId, live, now)) {
+					if (await this.publishBeacon(groupId, live, now, false).then(() => true, () => false)) live.leaving = now;
+				} else if (read || now - live.leaving > COMMUNITY_TOPOLOGY.beaconEveryMs) {
+					live.leaving = 0;
+					live.stepDownAt = now + this.timings.idleHubMs + Math.floor(this.random() * this.timings.idleHubMs);
+				}
+			} else if (idle && now >= live.stepDownAt && this.canStepDown(groupId, live, now)) {
+				live.stepDownAt = now + 3 * BEACON_RETRY_MS;
+				if ((live.beaconAt === now || await this.readBeacon(groupId, live, now)) && this.canStepDown(groupId, live, now) && await this.publishBeacon(groupId, live, now, false).then(() => true, () => false)) {
+					live.leaving = now;
+					await this.closeEntries(groupId);
+				}
+			}
+			if (!live.hub || live.leaving) {} else if (now - live.lastBeaconTry < BEACON_RETRY_MS) {} else if (now - live.lastBeaconWrite >= COMMUNITY_TOPOLOGY.beaconEveryMs || !live.beacon.some((h) => h.key === me) || now - live.lastBeaconWrite >= 5e3 && Math.abs(this.beaconLoad(groupId, live, now) - (live.beacon.find((h) => h.key === me)?.load ?? load)) >= 8) await this.publishBeacon(groupId, live, now, true).catch(() => {});
+		}
+		if (live.hub) {
+			for (const h of freshHubs(live.beacon, now)) if (h.ts + FAREWELL_SKEW_MS > (s.outAt(h.key) ?? Infinity)) this.wantFarewell(groupId, live, h.key, now);
 		}
+		this.endFarewells(live, now);
 		if (live.hub) {
 			const busy = this.admitting(groupId, live, now);
+			if (s.state.pendingLeaves.some((r) => r.s !== me && this.recentHub(live, r.s))) live.lobbyBusyUntil = Math.max(live.lobbyBusyUntil, now + this.timings.lobbyBusyMs);
 			const lobbyEvery = now < live.lobbyBusyUntil && !busy ? this.timings.lobbyPollMs : this.timings.lobbyIdlePollMs;
 			if (now - live.lastLobbyPoll >= lobbyEvery) {
 				live.lastLobbyPoll = now;
@@ -14157,26 +14679,41 @@ var Communities = class {
 			const edges = this.host.edges(groupId);
 			const fresh = new Set(others.map((h) => h.key));
 			for (const [key, until] of live.hubsAvoided) if (until <= now) live.hubsAvoided.delete(key);
+			const gone = live.myHubs.filter((key) => s.wasRemoved(key) || s.state.pendingLeaves.some((r) => r.s === key));
+			for (const key of gone) {
+				live.hubsAvoided.set(key, now + HUB_GRACE_MS);
+				live.hubWaits.delete(key);
+				live.hubsUp.delete(key);
+			}
 			for (const key of live.myHubs) {
+				if (gone.includes(key)) continue;
 				const id = edges.get(key);
 				if (id && this.host.linkReady(id, 2)) {
 					live.hubWaits.delete(key);
 					live.hubsUp.add(key);
+					live.replacing?.delete(key);
 					continue;
 				}
 				const since = live.hubWaits.get(key) ?? now;
 				live.hubWaits.set(key, since);
 				const back = live.hubsUp.has(key) && !!id && !!this.host.linkBack?.(id);
-				if (now - since > (back ? 3 : 1) * this.timings.hubWaitMs) {
+				if (now - since > (back || live.replacing?.has(key) ? 3 : 1) * this.timings.hubWaitMs) {
 					live.hubsAvoided.set(key, now + 2 * this.timings.hubWaitMs);
 					live.hubWaits.delete(key);
 					live.hubsUp.delete(key);
+					live.replacing?.delete(key);
 				}
 			}
 			let kept = live.myHubs.filter((key) => (fresh.has(key) || this.recentHub(live, key)) && !live.hubsAvoided.has(key));
 			kept = kept.slice(0, COMMUNITY_TOPOLOGY.hubsPerMember);
 			const picked = pickHubs(me, others, now, new Set(live.hubsAvoided.keys()));
-			for (const key of picked) if (kept.length < Math.max(1, picked.length) && !kept.includes(key)) kept.push(key);
+			for (const key of picked) if (kept.length < Math.max(1, picked.length) && !kept.includes(key)) {
+				kept.push(key);
+				if (gone.length) {
+					if (!edges.has(key)) live.expect.add(key);
+					(live.replacing ??= /* @__PURE__ */ new Set()).add(key);
+				}
+			}
 			live.myHubs = kept;
 			live.forceHub = !kept.length && others.length < COMMUNITY_TOPOLOGY.maxHubs;
 			for (const hub of kept) {
@@ -14200,7 +14737,7 @@ var Communities = class {
 		}
 		if (s.needsCatchUp && now - (live.lastCatchUp ?? 0) >= 5e3 || now - (live.lastCatchUp ?? 0) >= 3e4) {
 			live.lastCatchUp = now;
-			const ready = [...this.host.edges(groupId)].filter(([, id]) => this.host.linkReady(id, 2)).map(([key]) => key);
+			const ready = [...this.host.edges(groupId)].filter(([key, id]) => this.host.linkReady(id, 2) && !s.wasRemoved(key)).map(([key]) => key);
 			for (const key of ready.slice(0, 3)) s.catchUp(key);
 		}
 		await this.reconcile(groupId, live, now);
@@ -14226,8 +14763,32 @@ var Communities = class {
 			if (id && !this.host.linkReady(id, 2)) this.host.expectPeer(id);
 		}
 	}
+	/**
+	* May this idle hub step down? When enough other hubs are listed and it has an edge up to one that is listed now
+	* (a hub cut off from the others would only come back as one). It then steps down in two steps: it takes itself
+	* out of the beacon, still a hub, and is a member only once a later reading still lists a hub it has an edge to.
+	* Before, it was a member at once, and counted as hubs those it remembered from earlier readings. Hubs elected in
+	* the same seconds (the members of a hub that left) were idle in the same second a minute later, and two of them
+	* with an edge to each other only both stepped down, each counting on the other: each was the other's hub, neither
+	* was one, and the two heard nobody else until the memory of them ran out, minutes later. And a hub whose write the
+	* relays held back was no hub any more but stayed listed, so members went on asking it (2026-10-01).
+	*/
+	canStepDown(groupId, live, now) {
+		const me = live.session.myKey, others = freshHubs(this.hubs(live), now).filter((h) => h.key !== me);
+		if (others.length < COMMUNITY_TOPOLOGY.minHubs) return false;
+		const edges = this.host.edges(groupId);
+		return others.some((h) => {
+			const id = edges.get(h.key);
+			return !!id && this.host.linkReady(id, 2);
+		});
+	}
 	hubLoad(groupId, live, now) {
 		const edges = this.host.edges(groupId);
+		if (now - live.beaconAt <= 2 * this.timings.beaconReadMs) {
+			const hubs = new Set(freshHubs(this.hubs(live), now).map((h) => h.key));
+			for (const [key, id] of edges) if (!hubs.has(key) && !live.members.has(key) && this.host.linkReady(id, 2) && !live.session.wasRemoved(key)) live.members.set(key, now);
+			for (const key of [...live.members.keys()]) if (hubs.has(key)) live.members.delete(key);
+		}
 		for (const [key, since] of live.members) {
 			const id = edges.get(key);
 			if (id && this.host.linkReady(id, 2)) live.members.set(key, now);
@@ -14258,7 +14819,7 @@ var Communities = class {
 	capacity(groupId, live, now, entries = true) {
 		const room = this.host.peerRoom?.(groupId);
 		if (room === void 0) return COMMUNITY_TOPOLOGY.hubCapacity;
-		const hubs = new Set(freshHubs(live.beacon, now).map((h) => h.key));
+		const hubs = new Set(freshHubs(this.hubs(live), now).map((h) => h.key));
 		for (const key of this.host.edges(groupId).keys()) if (!live.members.has(key)) hubs.add(key);
 		hubs.delete(live.session.myKey);
 		const held = hubs.size + (entries ? this.host.entries(groupId).size : 0);
@@ -14269,13 +14830,72 @@ var Communities = class {
 		const n = live.members.size;
 		return n >= this.capacity(groupId, live, now, false) ? Math.max(n, COMMUNITY_TOPOLOGY.hubCapacity) : n;
 	}
+	/** Reads the beacon; false when the reading did not happen (the relays held it back, or none answered). */
 	async readBeacon(groupId, live, now) {
 		live.lastBeaconRead = now;
 		const keys = beaconKeys(live.session.state.rv, groupId);
-		const records = await this.host.resolve(keys.identity.pubKeyZ32, true).catch(() => null);
-		live.beacon = readBeacon(keys, records ?? []);
+		const records = await this.host.resolve(keys.identity.pubKeyZ32, true).catch(() => void 0);
+		if (records === void 0) {
+			live.beaconFailedAt = now;
+			live.beaconAskedAt ||= now;
+			if (live.session.roster.length === 1 || now - live.beaconAskedAt >= COMMUNITY_TOPOLOGY.beaconFreshMs) live.beaconKnown = true;
+			return false;
+		}
+		live.beaconFailedAt = 0;
+		live.beaconKnown = true;
+		live.beacon = this.inMyTime(live, readBeacon(keys, records ?? []), now);
 		live.head = readBeaconHead(keys, records ?? []);
+		live.beaconAt = now;
 		this.noteHubs(live, now);
+		return true;
+	}
+	/**
+	* A reading of the beacon in this app's time. A hub dates its entry by its own clock; held against mine as it is, a
+	* hub whose clock is a minute and a half from mine never looks fresh (its entry is "stale", or "not come yet"): a
+	* member saw no hub and took itself for the only one, and a hub with such a clock was no hub to anyone. So a hub's
+	* clock is learned from its entry: when the entry moved between two readings of mine, it was written between them,
+	* and what it says the time was then, against my own, is how far the two clocks are apart. An entry of a clock
+	* further than `HUB_CLOCK_SLACK_MS` from mine is moved by that much (its `since` with it); one closer, or one not
+	* seen to move yet, is taken as written, as before. An entry that stops moving ages by my clock like any other.
+	*/
+	inMyTime(live, read, now) {
+		const gap = now - live.beaconSeenAt;
+		for (const h of read) {
+			if (h.key === live.session.myKey) continue;
+			const known = live.hubClocks.get(h.key);
+			const moved = !!known && h.ts > known.said && live.beaconSeenAt > 0 && gap <= HUB_CLOCK_READ_GAP_MS;
+			live.hubClocks.set(h.key, {
+				said: Math.max(h.ts, known?.said ?? 0),
+				ahead: moved ? now - gap / 2 - h.ts : known?.ahead,
+				at: now
+			});
+		}
+		for (const [key, clock] of live.hubClocks) if (now - clock.at > HUB_CLOCK_KEPT_MS) live.hubClocks.delete(key);
+		live.beaconSeenAt = now;
+		return read.map((h) => {
+			const ahead = this.clockAhead(live, h.key);
+			return ahead ? {
+				...h,
+				ts: h.ts + ahead,
+				...h.since !== void 0 && { since: h.since + ahead }
+			} : h;
+		});
+	}
+	/** How far my clock is ahead of a hub's (ms, negative when behind), when the two differ; 0 when they agree or nothing says. */
+	clockAhead(live, hub) {
+		const ahead = hub === live.session.myKey ? 0 : live.hubClocks.get(hub)?.ahead ?? 0;
+		return Math.abs(ahead) > HUB_CLOCK_SLACK_MS ? Math.round(ahead) : 0;
+	}
+	/** Entries in my time, as each hub wrote them: what goes back into the beacon, so no hub's entry is dated by another's clock. */
+	asWritten(live, hubs) {
+		return hubs.map((h) => {
+			const ahead = this.clockAhead(live, h.key);
+			return ahead ? {
+				...h,
+				ts: h.ts - ahead,
+				...h.since !== void 0 && { since: h.since - ahead }
+			} : h;
+		});
 	}
 	/**
 	* The newest message frame I hold, for the beacon's head (WISP 9xx § Head): what a member's other profile on the
@@ -14296,9 +14916,11 @@ var Communities = class {
 		live.lastBeaconTry = now;
 		const keys = beaconKeys(live.session.state.rv, groupId);
 		let existing = live.beacon, head = live.head;
-		if (live.lastBeaconRead !== now) {
-			const records = await this.host.resolve(keys.identity.pubKeyZ32, true).catch(() => null) ?? [];
-			existing = readBeacon(keys, records);
+		if (live.lastBeaconRead !== now || live.beaconFailedAt === now) {
+			const read = await this.host.resolve(keys.identity.pubKeyZ32, true).catch(() => void 0);
+			if (read === void 0 && live.session.roster.length > 1) throw new Error("The beacon could not be read; not published");
+			const records = read ?? [];
+			existing = this.inMyTime(live, readBeacon(keys, records), now);
 			head = readBeaconHead(keys, records);
 		}
 		const hubs = mergeBeacon(existing, live.session.myKey, listed ? {
@@ -14308,15 +14930,80 @@ var Communities = class {
 			since: live.hubSince || now
 		} : null, now, (key) => !live.session.wasRemoved(key));
 		const newest = newerHead(head, this.newestFrame(live), now);
-		await this.host.publish(keys.identity, beaconRecords(keys, hubs, newest), true);
+		await this.host.publish(keys.identity, beaconRecords(keys, this.asWritten(live, hubs), newest), true);
 		live.beacon = hubs;
 		live.head = newest;
 		this.noteHubs(live, now);
 		live.lastBeaconWrite = now;
-		live.lastBeaconRead = now;
+		live.lastBeaconRead = live.beaconAt = now;
+		live.beaconFailedAt = 0;
+		live.beaconKnown = true;
+	}
+	/**
+	* The beacon's hubs, less those the chain took out: hubs are members. Someone removed while its app was closed lists
+	* itself there when it comes back, believing it is a member, until it is told (`wantFarewell`).
+	*/
+	hubs(live) {
+		const top = live.session.top, memo = live.hubsMemo;
+		if (memo && memo.beacon === live.beacon && memo.top === top) return memo.hubs;
+		const hubs = live.beacon.filter((h) => !live.session.wasRemoved(h.key));
+		live.hubsMemo = {
+			beacon: live.beacon,
+			top,
+			hubs
+		};
+		return hubs;
+	}
+	/** A frame goes on an edge to a member; to someone the chain took out, only the commit that took it out. */
+	mayHear(live, key, frame) {
+		if (!live?.session.wasRemoved(key)) return true;
+		const f = frame;
+		return f.t === "group-commit" && (f.commit?.k === "remove" || f.commit?.k === "leave") && f.commit.s === key;
+	}
+	/** The edges of the group that may hear `frame`. */
+	hearers(groupId, frame) {
+		const live = this.live.get(groupId);
+		return [...this.host.edges(groupId)].filter(([key]) => this.mayHear(live, key, frame));
+	}
+	/** As a hub: someone the chain took out is asking (in my lobby, or listing itself as a hub). An edge to tell it, within bounds. */
+	wantFarewell(groupId, live, key, now) {
+		if (key === live.session.myKey || live.farewells.has(key) || now < (live.farewellQuiet.get(key) ?? 0)) return;
+		if (live.farewells.size >= FAREWELL_EDGES || this.capacity(groupId, live, now) <= 0) return;
+		live.farewells.set(key, { since: now });
+		if (!this.host.edges(groupId).has(key)) live.expect.add(key);
+	}
+	/** Farewell edges end: told a moment ago, never came, or back in the group; and a hub no more keeps none. */
+	endFarewells(live, now) {
+		for (const [key, f] of live.farewells) {
+			const back = !live.session.wasRemoved(key);
+			if (!back && live.hub && (f.told ? now - f.told < FAREWELL_LINGER_MS : now - f.since < FAREWELL_WAIT_MS)) continue;
+			live.farewells.delete(key);
+			if (!back) live.farewellQuiet.set(key, now + (f.told ? FAREWELL_TOLD_MS : FAREWELL_RETRY_MS));
+		}
+		for (const [key, until] of live.farewellQuiet) if (until <= now) live.farewellQuiet.delete(key);
+		for (const [key, at] of live.farewellSaid) if (now - at >= FAREWELL_SAY_MS) live.farewellSaid.delete(key);
+	}
+	/**
+	* Someone the chain took out says where it is (`group-sync`): it is handed the commits up to the one that took it
+	* out, and nothing else (`CommunitySession.farewell`). Nothing else it says is heard.
+	*/
+	sayFarewell(groupId, live, key, sync) {
+		const now = this.now(), linkId = this.host.edges(groupId).get(key);
+		if (!linkId || now - (live.farewellSaid.get(key) ?? -Infinity) < FAREWELL_SAY_MS) return;
+		const frames = live.session.farewell(key, sync);
+		if (!frames.length) return;
+		live.farewellSaid.set(key, now);
+		try {
+			for (const frame of frames) this.host.sendOnLink(linkId, frame);
+		} catch {
+			return;
+		}
+		const waited = live.farewells.get(key);
+		if (waited) waited.told = now;
+		traceJoin(groupId, "farewell.sent");
 	}
 	noteHubs(live, now) {
-		for (const h of freshHubs(live.beacon, now)) live.seenHubs.set(h.key, now);
+		for (const h of freshHubs(this.hubs(live), now)) live.seenHubs.set(h.key, now);
 		for (const [key, at] of live.seenHubs) if (now - at > HUB_GRACE_MS) live.seenHubs.delete(key);
 	}
 	recentHub(live, key) {
@@ -14326,17 +15013,22 @@ var Communities = class {
 	async askHub(groupId, live, hub, now) {
 		const keys = lobbyKeys(live.session.state.rv, groupId, hub);
 		const existing = readLobby(keys, await this.host.resolve(keys.identity.pubKeyZ32, true) ?? []);
+		const theirs = now - this.clockAhead(live, hub);
 		await this.host.publish(keys.identity, lobbyRecords(keys, mergeLobby(existing, {
 			key: live.session.myKey,
-			ts: now
-		}, now)), true);
+			ts: theirs
+		}, theirs)), true);
 		traceJoin(groupId, "lobby.written");
 	}
 	async pollLobby(groupId, live, now) {
 		const keys = lobbyKeys(live.session.state.rv, groupId, live.session.myKey);
 		const entries = readLobby(keys, await this.host.resolve(keys.identity.pubKeyZ32, true).catch(() => null) ?? []);
 		for (const { key, ts } of entries) {
-			if (now - ts > COMMUNITY_TOPOLOGY.lobbyFreshMs || key === live.session.myKey || live.session.wasRemoved(key)) continue;
+			if (now - ts > COMMUNITY_TOPOLOGY.lobbyFreshMs || key === live.session.myKey) continue;
+			if (live.session.wasRemoved(key)) {
+				if (ts + FAREWELL_SKEW_MS > (live.session.outAt(key) ?? Infinity)) this.wantFarewell(groupId, live, key, now);
+				continue;
+			}
 			live.emptySince = now;
 			if (!live.members.has(key) && live.members.size >= this.capacity(groupId, live, now)) continue;
 			if (!live.members.has(key)) {
@@ -14353,10 +15045,11 @@ var Communities = class {
 		if (s.status === "active") {
 			if (live.hub) {
 				this.shed(groupId, live, now);
-				for (const h of freshHubs(live.beacon, now)) if (h.key !== s.myKey) wanted.add(h.key);
+				for (const h of freshHubs(this.hubs(live), now)) if (h.key !== s.myKey) wanted.add(h.key);
 				for (const key of live.members.keys()) wanted.add(key);
+				for (const key of live.farewells.keys()) wanted.add(key);
 			} else for (const key of live.myHubs) wanted.add(key);
-			for (const [key, id] of existing) if (this.host.linkReady(id, 2) && (live.members.has(key) || this.recentHub(live, key))) wanted.add(key);
+			for (const [key, id] of existing) if (this.host.linkReady(id, 2) && (live.members.has(key) || this.recentHub(live, key)) && !s.wasRemoved(key)) wanted.add(key);
 		}
 		for (const [key, since] of live.restored) {
 			if (!since) live.restored.set(key, now);
@@ -14411,7 +15104,7 @@ var Communities = class {
 			g: groupId,
 			host: s.entryKey
 		};
-		const hubs = doorHubs(live.beacon, now, s.myKey);
+		const hubs = doorHubs(this.hubs(live), now, s.myKey);
 		if (!hubs.includes(s.myKey)) return;
 		const door = [...hubs].sort()[0], doorSig = [...hubs].sort().join(",");
 		if (live.doors !== doorSig) {
@@ -14433,7 +15126,7 @@ var Communities = class {
 			ts
 		}));
 		for (const { key, ts } of knocks) {
-			if (now - ts > 18e4 || this.refused.has(key) || live.pendingEntries.has(key) || key === link.host) continue;
+			if (now - ts > 18e4 || this.refused.has(key) || live.pendingEntries.has(key) || key === link.host || key === s.myKey) continue;
 			const stillKnocking = now - ts < 2 * this.timings.slowKnockMs;
 			if (rosterHas(s.roster, key)) {
 				const added = [...s.state.chain].reverse().find((c) => c.k === "add" && c.s === key)?.ts ?? 0;
@@ -14510,14 +15203,23 @@ var Communities = class {
 			ms: Date.now() - started,
 			record: n
 		});
-		if (!this.knocked.has(group.id)) {
+		const others = knocks.filter((k) => k.key !== me && now - k.ts < 2 * this.timings.slowKnockMs).length;
+		const moved = (this.knockingWith.get(group.id) ?? 0) !== others;
+		this.knockingWith.set(group.id, others);
+		if (!this.knocked.has(group.id) || moved) {
 			this.knocked.add(group.id);
 			this.host.emit();
 		}
 	}
+	/**
+	* The entry sessions this device runs for joiners go (it is no door any more). Its own, when it is knocking at the
+	* link itself, stays: a hub taken out of the group that opened the link again at once had that session closed by
+	* its next tick (it stops being a hub and a door there), and knocked for good with nothing for a member to answer on.
+	*/
 	async closeEntries(groupId) {
-		this.live.get(groupId)?.pendingEntries.clear();
-		for (const linkId of this.host.entries(groupId).values()) await this.host.closeEdge(linkId);
+		const live = this.live.get(groupId), mine = this.stored.get(groupId)?.joining?.linkId;
+		live?.pendingEntries.clear();
+		for (const linkId of this.host.entries(groupId).values()) if (linkId !== mine) await this.host.closeEdge(linkId);
 	}
 	/** An entry session of a community came up with groups v2 on both sides: the hub invites. */
 	entryReady(groupId, linkId, peer) {
@@ -14602,7 +15304,16 @@ var Communities = class {
 					return;
 				}
 				traceJoin(g, "welcome.received");
-				const again = !!this.live.get(g);
+				const before = this.live.get(g)?.session, again = !!before;
+				if (before?.status === "active" && before.isMember) {
+					const mine = (chain) => [...chain].reverse().find((c) => c.k === "add" && c.s === before.myKey)?.sig;
+					if (mine(joined.state.chain) === mine(before.state.chain)) {
+						await this.endCheck(group);
+						return;
+					}
+					await this.event(g, "removed", "You were removed from this group", this.now(), joined.state.chain.length - 1);
+				}
+				const back = !!before && before.status !== "lost";
 				for (const [, id] of this.host.entries(g)) if (id !== linkId) await this.host.closeEdge(id);
 				const member = {
 					id: g,
@@ -14618,11 +15329,19 @@ var Communities = class {
 				live.expect.add(joining.inviter);
 				live.lobbyWrites.set(joining.inviter, now);
 				live.joinedAt = now;
+				const admission = [...joined.state.chain].reverse().find((c) => c.k === "add" && c.s === live.session.myKey);
+				if (admission?.by === joining.inviter) live.hubClocks.set(joining.inviter, {
+					said: 0,
+					ahead: now - admission.ts,
+					at: now
+				});
 				await this.store.putGroup(member);
 				if (!again) await this.event(g, "joined", `You joined. ${GROUP_READ_NOTE_COMMUNITY}`, now, joined.state.chain.length - 1);
+				else if (back) await this.event(g, "joined", "You joined again", now, joined.state.chain.length - 1);
 				this.lastKnock.delete(g);
 				this.knocked.delete(g);
 				this.knockAt.delete(g);
+				this.knockingWith.delete(g);
 				await this.host.closeEdge(linkId);
 				await this.reconcile(g, live, now);
 				this.host.emit();
@@ -14642,12 +15361,17 @@ var Communities = class {
 	/** A frame on an edge, from the member it is pinned to: handled, then relayed on by a hub. */
 	async handleEdgeFrame(groupId, peerKey, frame) {
 		const live = this.live.get(groupId);
-		if (!live || !frame || typeof frame !== "object" || live.session.wasRemoved(peerKey)) return;
+		if (!live || !frame || typeof frame !== "object") return;
 		const f = frame;
+		if (live.session.wasRemoved(peerKey)) {
+			if (f.t === "group-sync" && live.session.isMember) this.sayFarewell(groupId, live, peerKey, f);
+			return;
+		}
 		if ((f.t === "group-secret" || f.t === "group-entry") && typeof f.to === "string" && f.to !== live.session.myKey) {
 			if (!live.hub) return;
 			const id = `${String(f.t)}:${f.to}:${String(f.h ?? f.x)}`;
 			if (!this.remember(live, id)) return;
+			if (live.session.wasRemoved(f.to)) return;
 			const edges = this.host.edges(groupId), direct = edges.get(f.to);
 			if (direct && this.host.linkReady(direct, 2)) {
 				this.sendTo(direct, f);
@@ -14657,10 +15381,10 @@ var Communities = class {
 			return;
 		}
 		if (!await live.session.handle(peerKey, frame) || !live.hub) return;
-		for (const [key, id] of this.host.edges(groupId)) if (key !== peerKey) this.sendTo(id, f);
+		for (const [key, id] of this.hearers(groupId, f)) if (key !== peerKey) this.sendTo(id, f);
 	}
 	peerIsHub(live, key) {
-		return this.recentHub(live, key) && !live.members.has(key);
+		return this.recentHub(live, key) && !live.members.has(key) && !live.session.wasRemoved(key);
 	}
 	remember(live, id) {
 		if (live.relayed.has(id)) return false;
@@ -14668,14 +15392,16 @@ var Communities = class {
 		if (live.relayed.size > RELAYED_KEPT) live.relayed.delete(live.relayed.values().next().value);
 		return true;
 	}
+	/** True when the edge took the frame. */
 	sendTo(linkId, frame) {
-		if (!linkId || !this.host.linkReady(linkId, 2)) return;
+		if (!linkId || !this.host.linkReady(linkId, 2)) return false;
 		try {
 			this.host.sendOnLink(linkId, frame);
 		} catch {
-			return;
+			return false;
 		}
 		this.noteTaken(frame);
+		return true;
 	}
 	/** My frame went out on an edge (at first, or in a catch-up): the message it is, or the edit it carries, was taken. */
 	noteTaken(frame) {
@@ -14710,22 +15436,23 @@ var Communities = class {
 				group.community = next;
 				await this.store.putGroup(group);
 			},
-			broadcast: (frame) => {
-				for (const linkId of this.host.edges(id).values()) this.sendTo(linkId, frame);
+			broadcast: (frame) => this.hearers(id, frame).filter(([, linkId]) => this.sendTo(linkId, frame)).length,
+			direct: (to, frame) => {
+				if (this.mayHear(this.live.get(id), to, frame)) this.sendTo(this.host.edges(id).get(to), frame);
 			},
-			direct: (to, frame) => this.sendTo(this.host.edges(id).get(to), frame),
 			addressed: (to, frame) => {
 				const edges = this.host.edges(id), live = this.live.get(id);
 				const direct = edges.get(to);
+				if (live?.session.wasRemoved(to)) return;
 				if (direct && this.host.linkReady(direct, 2)) {
 					this.sendTo(direct, frame);
 					return;
 				}
 				const hubs = new Set(live ? [...live.seenHubs.keys()].filter((key) => this.recentHub(live, key)) : []);
-				for (const [key, linkId] of edges) if (hubs.has(key) || live?.myHubs.includes(key)) this.sendTo(linkId, frame);
+				for (const [key, linkId] of edges) if ((hubs.has(key) || live?.myHubs.includes(key)) && !live?.session.wasRemoved(key)) this.sendTo(linkId, frame);
 			},
 			message: async (m) => {
-				const timestamp = receivedTimestamp(m.timestamp);
+				const timestamp = m.timestamp;
 				const mentioned = m.sender !== session.myKey && mentionsMember(m.mentions, session.myKey);
 				const stored = await this.host.storeMessage({
 					linkId: MESSAGE_LINK$1(id),
@@ -14740,26 +15467,28 @@ var Communities = class {
 					...m.forwarded && { forwarded: m.forwarded },
 					...m.card && { card: m.card }
 				});
-				this.lastMessageAt.set(id, Math.max(this.lastMessageAt.get(id) ?? 0, timestamp));
-				const came = cameAt(timestamp, stored, this.now());
+				const came = m.sender === session.myKey ? timestamp : cameAt(timestamp, stored, arrivalNow(this.now()));
+				this.lastMessageAt.set(id, Math.max(this.lastMessageAt.get(id) ?? 0, came));
 				if (mentioned) this.lastMentionAt.set(id, Math.max(this.lastMentionAt.get(id) ?? 0, came));
 				if (m.sender !== session.myKey) this.lastPeerMessageAt.set(id, Math.max(this.lastPeerMessageAt.get(id) ?? 0, came));
+				noteCame(this.stored.get(id), came, m.sender !== session.myKey, mentioned);
 			},
 			app: (m) => this.deliver(id, () => this.host.communityApp?.(id, m.sender, m.frame)),
 			pair: (m) => this.deliver(id, () => this.host.communityPair?.(id, m.sender, m.payload)),
 			changed: () => {
 				this.membershipChanged(id);
 			},
-			metaChanged: (by, change) => {
+			metaChanged: (by, change, at) => {
 				const name = by === session.myKey ? "You" : session.state.nicks[by] ?? `Member ${by.slice(0, 8)}`;
+				const when = receivedTimestamp(at, this.now());
 				(async () => {
-					for (const line of metaLines(name, change, session.name)) await this.event(id, line.event, line.text, this.now(), session.epoch, by);
+					for (const line of metaLines(name, change, session.name)) await this.event(id, line.event, line.text, when, session.epoch, by);
 					this.host.emit();
 				})();
 			},
 			clock: () => this.now(),
 			relay: (frame) => {
-				if (this.live.get(id)?.hub) for (const linkId of this.host.edges(id).values()) this.sendTo(linkId, frame);
+				if (this.live.get(id)?.hub) for (const [, linkId] of this.hearers(id, frame)) this.sendTo(linkId, frame);
 			}
 		});
 		this.live.set(id, {
@@ -14767,8 +15496,15 @@ var Communities = class {
 			hub: false,
 			hubSince: 0,
 			beacon: [],
+			hubClocks: /* @__PURE__ */ new Map(),
+			beaconSeenAt: 0,
 			head: null,
 			lastBeaconRead: 0,
+			beaconKnown: false,
+			beaconFailedAt: 0,
+			beaconAt: 0,
+			leaving: 0,
+			stepDownAt: 0,
 			lastBeaconWrite: 0,
 			lastBeaconTry: 0,
 			hubCandidateAt: 0,
@@ -14786,6 +15522,9 @@ var Communities = class {
 			lingering: /* @__PURE__ */ new Map(),
 			seenHubs: /* @__PURE__ */ new Map(),
 			restored: /* @__PURE__ */ new Map(),
+			farewells: /* @__PURE__ */ new Map(),
+			farewellQuiet: /* @__PURE__ */ new Map(),
+			farewellSaid: /* @__PURE__ */ new Map(),
 			knocksScanned: false,
 			knockCursor: 0,
 			lastShardPoll: 0,
@@ -14814,22 +15553,17 @@ var Communities = class {
 		if (statusChanged && s.status === "removed") await this.event(groupId, "removed", s.state.statusReason ?? "You were removed from this group", when, s.epoch);
 		else if (statusChanged && s.status === "forked") await this.event(groupId, "forked", s.state.statusReason ?? "The membership history forked", when, s.epoch);
 		else if (s.status === "active" && before !== after) {
-			for (const [key] of after) if (!rosterHas(before, key) && key !== s.myKey) await this.event(groupId, "joined", `${name(key)} joined`, when, top.e, key);
-			for (const [key] of before) if (!rosterHas(after, key)) await this.event(groupId, "gone", `${name(key)} is no longer a member`, when, top.e, key);
-			if (top.k === "role" && before.find(([k]) => k === top.s)?.[1] !== "admin") await this.event(groupId, "admin", `${name(top.s)} ${top.s === s.myKey ? "are" : "is"} now the admin`, when, top.e, top.s);
-			if (top.k === "rotate") await this.event(groupId, "rotated", "Keys rotated: a fresh epoch", when, top.e);
+			const at = receivedTimestamp(top.ts, when);
+			for (const [key] of after) if (!rosterHas(before, key) && key !== s.myKey) await this.event(groupId, "joined", `${name(key)} joined`, at, top.e, key);
+			for (const [key] of before) if (!rosterHas(after, key)) await this.event(groupId, "gone", `${name(key)} is no longer a member`, at, top.e, key);
+			if (top.k === "role" && before.find(([k]) => k === top.s)?.[1] !== "admin") await this.event(groupId, "admin", `${name(top.s)} ${top.s === s.myKey ? "are" : "is"} now the admin`, at, top.e, top.s);
+			if (top.k === "rotate") await this.event(groupId, "rotated", "Keys rotated: a fresh epoch", at, top.e);
 		}
 		this.host.emit();
 	}
-	/**
-	* A line in the group's history. Its id carries its time, and the engine's clock moves once a tick: two
-	* lines of one kind within a tick (a picture changed, then removed) get distinct times, a millisecond
-	* apart, or the store would keep the first and drop the second as already there.
-	*/
+	/** A line in the group's history. Its id carries its time: two lines at the same moment get distinct ones (`eventTime`). */
 	async event(groupId, event, text, timestamp, epoch, member) {
-		const last = this.lastEventAt.get(groupId) ?? 0;
-		if (timestamp <= last) timestamp = last + 1;
-		this.lastEventAt.set(groupId, Math.max(last, timestamp));
+		timestamp = eventTime(this.eventTimes, groupId, timestamp);
 		await this.host.storeMessage({
 			linkId: MESSAGE_LINK$1(groupId),
 			id: `event:${epoch}:${event}:${member ?? ""}:${timestamp}`,
@@ -14841,7 +15575,7 @@ var Communities = class {
 			via: "datalink"
 		});
 	}
-	lastEventAt = /* @__PURE__ */ new Map();
+	eventTimes = /* @__PURE__ */ new Map();
 };
 //#endregion
 //#region ../browser/src/engine/meshHubs.ts
@@ -15256,7 +15990,7 @@ var MeshHubs = class {
 			...legacy.length ? { l: legacy } : {}
 		};
 		for (const [key, id] of edges) {
-			if (only && key !== only || !this.host.linkReady(id)) continue;
+			if (only && key !== only || !rosterHas(session.roster, key) || !this.host.linkReady(id)) continue;
 			try {
 				this.host.sendOnLink(id, frame);
 			} catch {}
@@ -15350,8 +16084,9 @@ var MeshHubs = class {
 		for (const [key, id] of this.host.edges(groupId)) {
 			if (key === from || !this.host.linkReady(id)) continue;
 			const member = rosterHas(session.roster, key);
+			const until = member ? Infinity : removalEpoch(session.state.chain, key);
 			for (const frame of frames) {
-				if (authorOf(frame) === key || !member && frame.t !== "group-commit") continue;
+				if (authorOf(frame) === key || !member && (frame.t !== "group-commit" || frame.commit.e > until)) continue;
 				try {
 					this.host.sendOnLink(id, frame);
 					sent++;
@@ -15363,6 +16098,14 @@ var MeshHubs = class {
 		return sent;
 	}
 };
+/**
+* The epoch of the commit that took `key` out of the group for the last time: the one after the last roster it was
+* in. -1 for a key the chain never had. Someone out of the roster is sent no commit past it.
+*/
+function removalEpoch(chain, key) {
+	for (let e = chain.length - 1; e >= 0; e--) if (rosterHas(chain[e].m, key)) return e + 1;
+	return -1;
+}
 function authorOf(frame) {
 	switch (frame.t) {
 		case "group-msg":
@@ -15450,7 +16193,7 @@ var GroupTypings = class {
 * knocking, and stayed "invited" for 10 minutes (2026-09-30).
 */
 function otherEndSeen(presence, dataLink, now = Date.now()) {
-	return !!dataLink && dataLink !== "idle" || !!presence?.online && now - presence.lastPacketAt < 3e4;
+	return !!dataLink && dataLink !== "idle" || !!presence?.online && now - presenceSeenAt(presence) < 3e4;
 }
 /** The key an edit of message `id` goes by in `FramesTaken`. */
 var editKey = (id, e) => `${id}#e${e}`;
@@ -15481,12 +16224,53 @@ var mentionAt = (map, groupId) => {
 	return at ? { lastMentionAt: at } : {};
 };
 /**
-* When a member's message counts as having come, for unread and the "@": when it reached me, if that is later than
-* when it was written (a catch-up from another member, a member back after a while). Written before I last looked at
-* the group but handed to me since, it is news here; by its own time it sorted among what I had read, and the group
-* never showed unread. A copy I had already (`stored` false) or one completed in place keeps its own time.
+* When a message counts as having come, for the list of groups, unread and the "@": when it reached me, never when
+* its sender says it was written (a member's clock ahead would keep the group unread and on top; written before I
+* last looked but handed to me since, a catch-up is news here). A copy I had already (`stored` false) or one
+* completed in place moves nothing forward: its own time, now at the latest.
+*/
+var cameAt = (timestamp, stored, now) => stored === false ? Math.min(timestamp, now) : now;
+/**
+* The time a line of a group's history is kept under: its own, or the next millisecond no other line of this run took.
+* A line's id carries its time, and two lines can share a moment (two members gone in one change, a picture changed
+* then removed within a tick): the store would keep the first and drop the second as already there. Only a time
+* already taken moves: a line older than the last one written (a rename read after a later commit, in a catch-up)
+* keeps its place.
+*/
+function eventTime(taken, groupId, timestamp) {
+	let times = taken.get(groupId);
+	if (!times) taken.set(groupId, times = /* @__PURE__ */ new Set());
+	while (times.has(timestamp)) timestamp++;
+	times.add(timestamp);
+	if (times.size > 1024) times.delete(times.values().next().value);
+	return timestamp;
+}
+/**
+* The moment something arrives, for the unread marks: this device's clock, never behind it. The engine's own clock is
+* its last tick's time, up to a second old, while the page marks a group read by the device's clock as it is looked at:
+* a message that came within that second of leaving the group counted as come before it was read, and the list showed
+* nothing new. (A simulation's clock runs ahead of the device's: it stands.)
+*/
+var arrivalNow = (tick) => Math.max(tick, Date.now());
+/**
+* Keeps on the group's record when a member's message came, where that is later than what it holds: the record is
+* saved with the session right after (a message taken moves its state), so a message handed to me late still makes
+* the group unread after the app starts again. Read from the history alone, by its own time, it sorted among what I
+* had read and the mark was gone on the next start.
 */
-var cameAt = (timestamp, stored, now) => stored === false ? timestamp : Math.max(timestamp, now);
+function noteCame(group, came, peer, mentioned) {
+	if (!group) return;
+	if (peer && came > (group.came?.peer ?? 0)) group.came = {
+		...group.came,
+		peer: came
+	};
+	if (mentioned && came > (group.came?.mention ?? 0)) group.came = {
+		...group.came,
+		mention: came
+	};
+}
+/** What `load` starts the unread marks from: the history's own times, or when its latest came if that was later. */
+var cameOrWritten = (written, came) => written === void 0 && came === void 0 ? void 0 : Math.max(written ?? 0, came ?? 0);
 /** The view's `lastPeerMessageAt`, when there is one. */
 var peerMessageAt = (map, groupId) => {
 	const at = map.get(groupId);
@@ -15500,6 +16284,7 @@ var ENTRY_TIMINGS = {
 	slowKnockMs: 2e4,
 	patienceMs: 12e4
 };
+var KNOCK_VERIFY_SPREAD_MS = 700;
 /** Entry sessions the admin runs at once; a joiner who does not finish in time is not answered again for a while. */
 var MAX_PENDING_ENTRIES = 4;
 var ENTRY_TIMEOUT_MS = 18e4;
@@ -15510,12 +16295,19 @@ var REFUSED_FOR_MS = 6e5;
 * doubling with each timeout in a row up to `REFUSED_FOR_MS`: a slow network is no refusal.
 */
 var ENTRY_RETRY_MS = 3e4;
-/** The welcome is on its way when the admin sends it; the session stays up a little for it to arrive. */
+/**
+* The welcome is on its way when the admin sends it; the session stays up a little for it to arrive. A joiner keeps
+* its side as long (unless its edge to the admin is up first): the admin says over it what it commits meanwhile.
+*/
 var ENTRY_LINGER_MS = 2e4;
 /** Taken out of a group, my edges stay this long: as a hub, the commit that removed me is passed on over them. */
 var REMOVED_LINGER_MS = 15e3;
 /** How long the tombstone of a group I left waits for the admin to hear it. */
 var LEFT_KEPT_MS = 6048e5;
+/** Syncs of a removed member answered with the commits it lacks, per farewell: it needs one. */
+var FAREWELL_ANSWERS = 3;
+/** Commits sent to a removed member that was behind when it left, at most. */
+var FAREWELL_COMMITS = 64;
 /** Where a member's gossip turns start among the members it is connected to: a number of its own, from its key. */
 var gossipStart = (key) => {
 	let n = 0;
@@ -15594,8 +16386,21 @@ var Groups = class {
 	/** Admin side: until when a group's link is looked at the warm pace. */
 	warmUntil = /* @__PURE__ */ new Map();
 	lastKnock = /* @__PURE__ */ new Map();
+	/** Joiner side: when a knock just written is read back (`KNOCK_VERIFY_MS`); none once it was found there. */
+	knockCheckAt = /* @__PURE__ */ new Map();
+	/** Joiner side: knocks written in a row without one found in the record since (`KNOCK_VERIFIES`). */
+	knockRewrites = /* @__PURE__ */ new Map();
 	/** Per group, members met over their admission a moment ago: their edge is opened expecting them. */
 	justMet = /* @__PURE__ */ new Map();
+	/**
+	* Admin side: joiners let in through the link whose entry session is still open, per group: member key → link id.
+	* Until the edge to one of them is up, a commit made meanwhile (the next joiner's admission) goes to it over that
+	* session: it would otherwise seal what it writes for a roster that is no longer the group's, and whoever was let
+	* in since could never read it (two people open the link together, both say hello, one never sees the other's).
+	*/
+	welcomed = /* @__PURE__ */ new Map();
+	/** Joiner side: the entry session I was let in through, kept until my edge to the admin is up or `until`. */
+	lingering = /* @__PURE__ */ new Map();
 	/** Joiner side: groups whose knock is published, for the stage the joiner is shown. */
 	knocked = /* @__PURE__ */ new Set();
 	/**
@@ -15651,9 +16456,11 @@ var Groups = class {
 			const history = await this.store.getMessages(MESSAGE_LINK(group.id)), said = history.filter((m) => !m.event && !m.groupPay);
 			const last = said[said.length - 1], lastPeer = [...said].reverse().find((m) => m.sender !== "me");
 			if (last) this.lastMessageAt.set(group.id, last.timestamp);
-			if (lastPeer) this.lastPeerMessageAt.set(group.id, lastPeer.timestamp);
+			const peerAt = cameOrWritten(lastPeer?.timestamp, lastPeer ? group.came?.peer : void 0);
+			if (peerAt) this.lastPeerMessageAt.set(group.id, peerAt);
 			const mention = [...history].reverse().find((m) => m.mentioned);
-			if (mention) this.lastMentionAt.set(group.id, mention.timestamp);
+			const mentionAt = cameOrWritten(mention?.timestamp, mention ? group.came?.mention : void 0);
+			if (mentionAt) this.lastMentionAt.set(group.id, mentionAt);
 		}
 		for (const id of this.sessions.keys()) this.reconcileEdges(id);
 		for (const group of this.stored.values()) for (const [, linkId] of this.host.entries(group.id)) if (!group.invitation?.entry || group.invitation.linkId !== linkId) await this.host.closeEdge(linkId);
@@ -15957,6 +16764,8 @@ var Groups = class {
 		delete group.entry;
 		this.invited.delete(groupId);
 		this.pendingEntries.delete(groupId);
+		this.welcomed.delete(groupId);
+		this.lingering.delete(groupId);
 		this.lastMessageAt.delete(groupId);
 		this.lastPeerMessageAt.delete(groupId);
 		this.lastMentionAt.delete(groupId);
@@ -15989,25 +16798,138 @@ var Groups = class {
 	}
 	async remove(groupId, key) {
 		if (this.isCommunity(groupId)) return this.communities.remove(groupId, key);
-		await this.session(groupId).remove(key);
-		const contact = this.stored.get(groupId).contacts?.[key];
+		const session = this.session(groupId), group = this.stored.get(groupId);
+		const edge = this.host.edges(groupId).get(key), edgeUp = !!edge && this.host.linkReady(edge);
+		const noted = !edgeUp && session.isAdmin && rosterHas(session.roster, key) && key !== session.myKey;
+		if (noted) {
+			this.noteFarewell(group, key, session.epoch + 1);
+			if (edge && this.host.linkOpen?.(edge)) group.farewells[key].opened = this.now();
+		}
+		try {
+			await session.remove(key);
+		} catch (error) {
+			if (noted) this.dropFarewell(group, key);
+			throw error;
+		}
+		const contact = group.contacts?.[key];
+		let told = edgeUp;
 		if (contact) try {
 			this.host.sendOnLink(contact, {
 				t: "group-removed",
 				g: groupId
 			});
+			told = true;
 		} catch {}
+		if (noted && told) this.dropFarewell(group, key);
+		if (noted) {
+			await this.store.putGroup(group);
+			this.reconcileEdges(groupId);
+		}
 	}
-	makeAdmin(groupId, key) {
-		return this.isCommunity(groupId) ? this.communities.makeAdmin(groupId, key) : this.session(groupId).transferAdmin(key);
+	/** A member removed while it cannot be told: its edge stays until it opens (see `StoredGroup.farewells`). The oldest go past `MAX_FAREWELLS`. */
+	noteFarewell(group, key, e) {
+		const kept = Object.entries(group.farewells ?? {}).filter(([k]) => k !== key).sort(([, a], [, b]) => b.at - a.at).slice(0, 7);
+		group.farewells = Object.fromEntries([...kept, [key, {
+			at: this.now(),
+			e
+		}]]);
 	}
-	/**
-	* The admin pins a member of a private group as a hub, excludes one from being a hub, or leaves it to the member's
-	* app (`null`): said in the group's metadata, which every member keeps (WISP 9xx · Group Mesh § Hubs).
-	*/
-	async setHub(groupId, key, role) {
-		if (this.isCommunity(groupId)) throw new Error("A community group chooses its hubs by itself");
-		await this.session(groupId).setHub(key, role);
+	dropFarewell(group, key) {
+		if (!group.farewells?.[key]) return;
+		const { [key]: _gone, ...rest } = group.farewells;
+		group.farewells = Object.keys(rest).length ? rest : void 0;
+	}
+	/** The removed members this admin still waits for: not told yet, or told a moment ago (the commit is on its way). */
+	farewellKeys(group, session, now) {
+		if (!group?.farewells || session.status !== "active") return [];
+		return Object.entries(group.farewells).filter(([key, f]) => !rosterHas(session.roster, key) && now - f.at <= 6048e5 && (f.told === void 0 || now - f.told < REMOVED_LINGER_MS) && (f.opened === void 0 || now - f.opened < 6e4)).map(([key]) => key);
+	}
+	/** The edges an active member keeps: what the roster (or the hubs) ask for, and those to members it removed while they were away. */
+	edgesWanted(groupId, session, group, now) {
+		const wanted = this.hubs.edgesWanted(groupId, session, group, now), farewells = this.farewellKeys(group, session, now);
+		return farewells.length ? /* @__PURE__ */ new Set([...wanted, ...farewells]) : wanted;
+	}
+	/** A member key in the roster of a private group I am active in (a community: its own engine answers). */
+	inRoster(groupId, key) {
+		const session = this.sessions.get(groupId);
+		return !!session && session.status === "active" && rosterHas(session.roster, key);
+	}
+	/** A key out of the roster of a private group I am active in: a former member, or a stranger. */
+	outsider(groupId, key) {
+		const session = this.sessions.get(groupId);
+		return !!session && session.status === "active" && !rosterHas(session.roster, key);
+	}
+	/**
+	* Whether a frame may go over a private group's edge to `key`. To a member, anything. To someone out of the roster
+	* of a group I am active in, only the commits up to the one that took it out: an edge to a former member exists a
+	* moment (its last commit is on its way) or is kept to tell it (`StoredGroup.farewells`), and carries nothing else.
+	*/
+	edgeAllows(groupId, key, frame) {
+		const session = this.sessions.get(groupId);
+		if (!session || session.status !== "active" || rosterHas(session.roster, key)) return true;
+		const commit = frame && typeof frame === "object" && frame.t === "group-commit" ? frame.commit : void 0;
+		return typeof commit?.e === "number" && commit.e <= removalEpoch(session.state.chain, key);
+	}
+	/** The connection of an edge opened. One kept to tell a removed member closes a while after, whatever its app says or does not say. */
+	edgeOpen(groupId, peerKey) {
+		const group = this.stored.get(groupId), farewell = group?.farewells?.[peerKey];
+		if (!group || !farewell || farewell.opened !== void 0) return;
+		farewell.opened = this.now();
+		this.store.putGroup(group).catch(() => {});
+	}
+	/**
+	* The edge to a member I removed while it was away came up: the commit that removed it goes now, which is all this
+	* edge carries. Its app applies it when it had followed the chain to the commit before; one further behind says
+	* where it is in its sync, and gets the commits between (`farewellSync`). No secret goes with any of them.
+	*/
+	sayFarewell(groupId, session, group, key, linkId) {
+		const farewell = group.farewells[key], commit = session.state.chain[farewell.e];
+		if (!commit) {
+			this.dropFarewell(group, key);
+			return;
+		}
+		try {
+			this.host.sendOnLink(linkId, {
+				t: "group-commit",
+				g: groupId,
+				commit
+			});
+		} catch {
+			return;
+		}
+		farewell.told ??= this.now();
+		this.store.putGroup(group).catch(() => {});
+	}
+	/** The sync of a removed member I wait for: the commits it lacks up to the one that removed it, a few times at most. */
+	farewellSync(groupId, session, group, key, frame) {
+		const farewell = group.farewells[key], linkId = this.host.edges(groupId).get(key);
+		const from = frame.e;
+		if (!linkId || frame.t !== "group-sync" || !Number.isSafeInteger(from) || from < 0 || from >= farewell.e - 1) return;
+		if ((farewell.answered ?? 0) >= FAREWELL_ANSWERS) return;
+		farewell.answered = (farewell.answered ?? 0) + 1;
+		try {
+			for (let e = Math.max(from + 1, farewell.e - FAREWELL_COMMITS); e <= farewell.e; e++) {
+				const commit = session.state.chain[e];
+				if (commit) this.host.sendOnLink(linkId, {
+					t: "group-commit",
+					g: groupId,
+					commit
+				});
+			}
+		} catch {}
+		farewell.told ??= this.now();
+		this.store.putGroup(group).catch(() => {});
+	}
+	makeAdmin(groupId, key) {
+		return this.isCommunity(groupId) ? this.communities.makeAdmin(groupId, key) : this.session(groupId).transferAdmin(key);
+	}
+	/**
+	* The admin pins a member of a private group as a hub, excludes one from being a hub, or leaves it to the member's
+	* app (`null`): said in the group's metadata, which every member keeps (WISP 9xx · Group Mesh § Hubs).
+	*/
+	async setHub(groupId, key, role) {
+		if (this.isCommunity(groupId)) throw new Error("A community group chooses its hubs by itself");
+		await this.session(groupId).setHub(key, role);
 		this.host.emit();
 	}
 	rotate(groupId) {
@@ -16035,7 +16957,11 @@ var Groups = class {
 		this.lastTold.delete(groupId);
 		this.pendingEntries.delete(groupId);
 		this.knocked.delete(groupId);
+		this.knockCheckAt.delete(groupId);
+		this.knockRewrites.delete(groupId);
 		this.justMet.delete(groupId);
+		this.welcomed.delete(groupId);
+		this.lingering.delete(groupId);
 		this.relayAsked.delete(groupId);
 		this.hubs.forget(groupId);
 		this.removedAt.delete(groupId);
@@ -16103,7 +17029,7 @@ var Groups = class {
 		if (existing?.state?.status === "active" || existing?.invitation?.entry === link.host) return link.g;
 		if (existing?.invitation?.seedB64 && !existing.invitation.entry) throw new Error("You are already joining this group");
 		if (existing) await this.forget(link.g);
-		const seedB64 = createIdentity().seedB64;
+		const seedB64 = dialedKey(link);
 		const linkId = await this.host.openEntry(link, "guest", seedB64, link.host);
 		const group = {
 			id: link.g,
@@ -16138,7 +17064,7 @@ var Groups = class {
 				}
 				if (group.invitation?.entry && !group.state) {
 					const every = now - group.createdAt > this.timings.patienceMs ? this.timings.slowKnockMs : this.timings.knockMs;
-					if (!(this.host.linkReady(group.invitation.linkId) || !!this.host.linkSeen?.(group.invitation.linkId)) && now - (this.lastKnock.get(group.id) ?? 0) >= every) await this.knock(group, now).catch(() => {});
+					if (!(this.host.linkReady(group.invitation.linkId) || !!this.host.linkSeen?.(group.invitation.linkId)) && (now - (this.lastKnock.get(group.id) ?? 0) >= every || now >= (this.knockCheckAt.get(group.id) ?? Infinity))) await this.knock(group, now).catch(() => {});
 					continue;
 				}
 				const session = this.sessions.get(group.id);
@@ -16167,6 +17093,7 @@ var Groups = class {
 			}
 			for (const [key, until] of this.refused) if (until <= now) this.refused.delete(key);
 			for (const [key, { at }] of this.entryTimeouts) if (now - at > 36e5) this.entryTimeouts.delete(key);
+			for (const [groupId, kept] of this.lingering) if (now >= kept.until) await this.endLinger(groupId);
 			this.meshTick(now);
 			await this.communities.tick(now);
 			await this.hubsTick(now);
@@ -16188,7 +17115,7 @@ var Groups = class {
 			if (!group || group.left || session.status !== "active" || !this.hubs.large(session)) continue;
 			await this.hubs.tick(groupId, session, group, now).catch(() => false);
 			if (this.hubReconcile.has(groupId)) continue;
-			const wanted = this.hubs.edgesWanted(groupId, session, group, now);
+			const wanted = this.edgesWanted(groupId, session, group, now);
 			const edges = this.host.edges(groupId);
 			if ([...wanted].some((key) => !edges.has(key)) || [...edges.keys()].some((key) => !wanted.has(key))) {
 				this.hubReconcile.add(groupId);
@@ -16235,8 +17162,16 @@ var Groups = class {
 			seedB64: group.entry.seedB64
 		} : void 0;
 	}
+	/** Joiner side: the entry session kept after the welcome goes (the edge to the admin is up, or it was kept long enough). */
+	async endLinger(groupId) {
+		const kept = this.lingering.get(groupId);
+		if (!kept) return;
+		this.lingering.delete(groupId);
+		if ([...this.host.entries(groupId).values()].includes(kept.linkId)) await this.host.closeEdge(kept.linkId);
+	}
 	async closeEntries(groupId) {
 		this.pendingEntries.delete(groupId);
+		this.welcomed.delete(groupId);
 		const invited = this.invited.get(groupId);
 		for (const linkId of this.host.entries(groupId).values()) {
 			invited?.delete(linkId);
@@ -16251,15 +17186,29 @@ var Groups = class {
 			host: invitation.entry
 		}, identity = knockIdentity(link);
 		const started = Date.now();
+		this.knockCheckAt.delete(group.id);
 		const existing = readKnocks(link, await this.host.resolve(identity.pubKeyZ32) ?? []);
+		const key = identityFromSeedB64(invitation.seedB64).pubKeyZ32, mine = existing.find((k) => k.key === key);
 		traceJoin(group.id, "knock.read", {
 			ms: Date.now() - started,
-			others: existing.length
+			others: existing.length,
+			...mine ? { mine: now - mine.ts } : {}
 		});
+		if (mine && now - mine.ts >= 0 && now - mine.ts < 3e4) {
+			this.knockRewrites.delete(group.id);
+			if (!this.knocked.has(group.id)) {
+				this.knocked.add(group.id);
+				this.host.emit();
+			}
+			return;
+		}
 		await this.host.publish(identity, knockRecords(link, mergeKnocks(existing, {
-			key: identityFromSeedB64(invitation.seedB64).pubKeyZ32,
+			key,
 			ts: now
 		}, now)));
+		const rewrites = (this.knockRewrites.get(group.id) ?? 0) + 1;
+		this.knockRewrites.set(group.id, rewrites);
+		if (rewrites <= 2) this.knockCheckAt.set(group.id, now + 800 + gossipStart(key) % KNOCK_VERIFY_SPREAD_MS);
 		traceJoin(group.id, "knock.published", { ms: Date.now() - started });
 		if (!this.knocked.has(group.id)) {
 			this.knocked.add(group.id);
@@ -16375,7 +17324,11 @@ var Groups = class {
 					this.entryTimeouts.delete(entryPeer);
 					this.pendingEntries.get(g)?.delete(entryPeer);
 					this.host.entryDone?.(linkId);
+					let welcomed = this.welcomed.get(g);
+					if (!welcomed) this.welcomed.set(g, welcomed = /* @__PURE__ */ new Map());
+					welcomed.set(entryPeer, linkId);
 					setTimeout(() => {
+						if (this.welcomed.get(g)?.get(entryPeer) === linkId) this.welcomed.get(g).delete(entryPeer);
 						if (this.host.entries(g).get(entryPeer) === linkId) this.host.closeEdge(linkId);
 					}, ENTRY_LINGER_MS);
 				}
@@ -16423,6 +17376,11 @@ var Groups = class {
 				};
 				this.stored.set(g, member);
 				this.attach(joined.state);
+				if (viaLink) this.lingering.set(g, {
+					linkId,
+					admin: group.invitation.admin,
+					until: this.now() + ENTRY_LINGER_MS
+				});
 				await this.store.putGroup(member);
 				if (!viaLink) await this.sessions.get(g).setNick(group.invitation.admin, this.host.contactName(linkId));
 				await this.event(g, "joined", `You joined. ${GROUP_READ_NOTE}`, Date.now(), joined.state.chain.length - 1);
@@ -16430,12 +17388,18 @@ var Groups = class {
 				if (viaLink) {
 					this.lastKnock.delete(g);
 					this.knocked.delete(g);
-					await this.host.closeEdge(linkId);
 				}
 				this.reconcileEdges(g);
 				this.host.emit();
 				return;
 			}
+			case "group-commit": {
+				const kept = this.lingering.get(g), session = this.sessions.get(g);
+				if (!kept || kept.linkId !== linkId || !session) return;
+				const taken = await session.handle(kept.admin, frame);
+				if (taken.length) this.hubs.passOn(g, session, kept.admin, taken);
+				return;
+			}
 			case "group-removed": {
 				const session = this.sessions.get(g);
 				const group = this.stored.get(g);
@@ -16463,6 +17427,10 @@ var Groups = class {
 			}
 		}
 	}
+	/** A key the group's chain had as a member and has no more (not one it never had: a member my chain has not reached yet). */
+	tookOut(session, key) {
+		return !rosterHas(session.roster, key) && removalEpoch(session.state.chain, key) >= 0;
+	}
 	/** A `group-*` frame on an edge: from the member the edge is pinned to. */
 	async handleEdgeFrame(groupId, peerKey, frame) {
 		if (this.isCommunity(groupId)) return this.communities.handleEdgeFrame(groupId, peerKey, frame);
@@ -16471,6 +17439,12 @@ var Groups = class {
 			return;
 		}
 		const session = this.sessions.get(groupId);
+		const waiting = this.stored.get(groupId);
+		if (session && waiting?.farewells?.[peerKey] && !rosterHas(session.roster, peerKey)) {
+			if (session.status === "active" && frame && typeof frame === "object") this.farewellSync(groupId, session, waiting, peerKey, frame);
+			return;
+		}
+		if (session?.status === "active" && this.tookOut(session, peerKey)) return;
 		if (session?.status === "active" && frame && typeof frame === "object" && frame.t === "group-here") {
 			this.heardHere(groupId, session, peerKey, frame);
 			return;
@@ -16559,6 +17533,10 @@ var Groups = class {
 			return;
 		}
 		const session = this.sessions.get(groupId), group = this.stored.get(groupId);
+		if (session?.status === "active" && group?.farewells?.[peerKey] && !rosterHas(session.roster, peerKey)) {
+			this.sayFarewell(groupId, session, group, peerKey, linkId);
+			return;
+		}
 		if (!session || !group || session.status !== "active" || !rosterHas(session.roster, peerKey)) return;
 		const large = this.host.linkReady(linkId, 3) && this.markLarge(group, peerKey);
 		const legacy = this.hubs.enabled && this.hubs.edgeReady(groupId, session, group, peerKey, this.host.linkReady(linkId, 4), this.now());
@@ -16568,6 +17546,8 @@ var Groups = class {
 		} catch {
 			return;
 		}
+		if (this.lingering.get(groupId)?.admin === peerKey) this.endLinger(groupId).catch(() => {});
+		this.welcomed.get(groupId)?.delete(peerKey);
 		this.announceHere(groupId, session, peerKey);
 		this.host.edgeUp?.(groupId, peerKey);
 		this.host.emit();
@@ -16687,6 +17667,7 @@ var Groups = class {
 		if (reconcile) this.lastReconcile = now;
 		for (const [groupId, session] of this.sessions) {
 			if (session.status !== "active" || this.stored.get(groupId)?.left) continue;
+			this.farewellsTick(groupId, session, now);
 			if (reconcile) {
 				const edges = this.host.edges(groupId);
 				if (!this.hubs.large(session) && session.others.some((key) => !edges.has(key))) this.reconcileEdges(groupId);
@@ -16710,12 +17691,25 @@ var Groups = class {
 			} catch {}
 		}
 	}
+	/** A removed member told a moment ago, or waited for a week: its edge goes, and nothing more is kept about it. */
+	farewellsTick(groupId, session, now) {
+		const group = this.stored.get(groupId);
+		if (!group?.farewells) return;
+		const waiting = new Set(this.farewellKeys(group, session, now));
+		const done = Object.keys(group.farewells).filter((key) => !waiting.has(key));
+		if (!done.length) return;
+		for (const key of done) this.dropFarewell(group, key);
+		this.store.putGroup(group).catch(() => {});
+		this.reconcileEdges(groupId);
+	}
 	edgeNick(groupId, peerKey, nick) {
 		if (this.isCommunity(groupId)) {
 			this.communities.edgeNick(groupId, peerKey, nick);
 			return;
 		}
-		this.sessions.get(groupId)?.setNick(peerKey, nick);
+		const session = this.sessions.get(groupId);
+		if (session && this.stored.get(groupId)?.farewells?.[peerKey] && !rosterHas(session.roster, peerKey)) return;
+		session?.setNick(peerKey, nick);
 	}
 	session(groupId) {
 		const session = this.sessions.get(groupId);
@@ -16733,10 +17727,14 @@ var Groups = class {
 			},
 			send: (to, frame) => {
 				const edge = this.host.edges(state.id).get(to);
-				if (!edge) return;
 				try {
+					if (!edge) throw new Error("no edge");
 					this.host.sendOnLink(edge, frame);
 				} catch {
+					const entry = frame.t === "group-commit" ? this.welcomed.get(state.id)?.get(to) : void 0;
+					if (entry) try {
+						this.host.sendOnLink(entry, frame);
+					} catch {}
 					return;
 				}
 				if ((frame.t === "group-msg" || frame.t === "group-edit") && frame.s === session.myKey) {
@@ -16745,7 +17743,7 @@ var Groups = class {
 				}
 			},
 			message: async (m) => {
-				const timestamp = receivedTimestamp(m.timestamp);
+				const timestamp = m.timestamp;
 				const mentioned = m.sender !== session.myKey && mentionsMember(m.mentions, session.myKey);
 				const message = {
 					linkId: MESSAGE_LINK(state.id),
@@ -16761,10 +17759,11 @@ var Groups = class {
 					...m.card && { card: m.card }
 				};
 				const stored = m.completes && this.host.completeMessage ? (await this.host.completeMessage(message), false) : await this.host.storeMessage(message);
-				this.lastMessageAt.set(state.id, Math.max(this.lastMessageAt.get(state.id) ?? 0, timestamp));
-				const came = cameAt(timestamp, stored, this.now());
+				const came = m.sender === session.myKey ? timestamp : cameAt(timestamp, stored, arrivalNow(this.now()));
+				this.lastMessageAt.set(state.id, Math.max(this.lastMessageAt.get(state.id) ?? 0, came));
 				if (mentioned) this.lastMentionAt.set(state.id, Math.max(this.lastMentionAt.get(state.id) ?? 0, came));
 				if (m.sender !== session.myKey) this.lastPeerMessageAt.set(state.id, Math.max(this.lastPeerMessageAt.get(state.id) ?? 0, came));
+				noteCame(this.stored.get(state.id), came, m.sender !== session.myKey, mentioned);
 				this.typings.messageFrom(state.id, m.sender);
 			},
 			edit: (e) => this.host.groupEdit?.(state.id, e),
@@ -16772,8 +17771,8 @@ var Groups = class {
 				if (session.status === "removed" && this.hubs.isHub(state.id) && !this.removedAt.has(state.id)) this.removedAt.set(state.id, this.now());
 				this.membershipChanged(state.id);
 			},
-			metaChanged: (by, change) => {
-				this.metaChanged(state.id, session, by, change);
+			metaChanged: (by, change, at) => {
+				this.metaChanged(state.id, session, by, change, at);
 			}
 		});
 		this.sessions.set(state.id, session);
@@ -16795,7 +17794,7 @@ var Groups = class {
 			top
 		});
 		const name = (key) => key === session.myKey ? "You" : session.state.nicks[key] ?? `Member ${key.slice(0, 8)}`;
-		const when = Date.now();
+		const when = moved ? receivedTimestamp(top.ts) : Date.now();
 		if (session.status === "removed") {
 			if (statusChanged) await this.event(groupId, "removed", session.state.statusReason ?? "You were removed from this group", when, session.epoch);
 		} else if (session.status === "forked") {
@@ -16817,9 +17816,11 @@ var Groups = class {
 		this.host.membersChanged?.(groupId);
 		this.host.emit();
 	}
-	async metaChanged(groupId, session, by, change) {
+	/** `at`: when the admin signed the statement (the line's time, as a commit's is its line's). */
+	async metaChanged(groupId, session, by, change, at) {
 		const name = by === session.myKey ? "You" : session.state.nicks[by] ?? `Member ${by.slice(0, 8)}`;
-		for (const line of metaLines(name, change, session.name)) await this.event(groupId, line.event, line.text, Date.now(), session.epoch, by);
+		const when = at === void 0 ? Date.now() : receivedTimestamp(at);
+		for (const line of metaLines(name, change, session.name)) await this.event(groupId, line.event, line.text, when, session.epoch, by);
 		this.host.emit();
 	}
 	/**
@@ -16832,7 +17833,7 @@ var Groups = class {
 			const existing = this.host.edges(groupId);
 			const left = group?.left;
 			const removed = this.removedAt.get(groupId);
-			const wanted = session?.status === "active" && group ? this.hubs.edgesWanted(groupId, session, group, this.now()) : left ? /* @__PURE__ */ new Set([left.admin, ...left.hubs ?? []]) : removed !== void 0 && this.now() - removed < REMOVED_LINGER_MS ? new Set(existing.keys()) : /* @__PURE__ */ new Set();
+			const wanted = session?.status === "active" && group ? this.edgesWanted(groupId, session, group, this.now()) : left ? /* @__PURE__ */ new Set([left.admin, ...left.hubs ?? []]) : removed !== void 0 && this.now() - removed < REMOVED_LINGER_MS ? new Set(existing.keys()) : /* @__PURE__ */ new Set();
 			for (const [key, linkId] of existing) if (!wanted.has(key)) await this.host.closeEdge(linkId);
 			const met = this.justMet.get(groupId);
 			if (session) {
@@ -16854,11 +17855,9 @@ var Groups = class {
 		this.hubs.met(groupId, key, this.now());
 	}
 	/** `member`: whom it is about, so the apps can name them as they are known now, not as they were then. */
-	/** A line in the group's history; lines at the same time (two members gone in one change) get distinct ones, see `Communities.event`. */
+	/** A line in the group's history; lines at the same time (two members gone in one change) get distinct ones, see `eventTime`. */
 	async event(groupId, event, text, timestamp, epoch, member) {
-		const last = this.lastEventAt.get(groupId) ?? 0;
-		if (timestamp <= last) timestamp = last + 1;
-		this.lastEventAt.set(groupId, Math.max(last, timestamp));
+		timestamp = eventTime(this.eventTimes, groupId, timestamp);
 		await this.host.storeMessage({
 			linkId: MESSAGE_LINK(groupId),
 			id: `event:${epoch}:${event}:${timestamp}`,
@@ -16870,7 +17869,7 @@ var Groups = class {
 			via: "datalink"
 		});
 	}
-	lastEventAt = /* @__PURE__ */ new Map();
+	eventTimes = /* @__PURE__ */ new Map();
 };
 //#endregion
 //#region ../browser/src/engine/groupEdges.ts
@@ -16884,7 +17883,7 @@ function edgeView(live, now = Date.now(), noSlot = false) {
 		linkId: live.stored.id,
 		state: "waiting",
 		noSlot: true,
-		lastSeenAt: Math.max(live.presence.lastPacketAt, live.lastSyncAt)
+		lastSeenAt: Math.max(presenceSeenAt(live.presence), live.lastSyncAt)
 	};
 	const error = open ? void 0 : live.pairing?.status === "error" ? live.pairing.error : live.discoveryError;
 	const state = open ? "open" : error ? "error" : live.dataLink !== "idle" ? "connecting" : "waiting";
@@ -16892,7 +17891,7 @@ function edgeView(live, now = Date.now(), noSlot = false) {
 		linkId: live.stored.id,
 		state,
 		...open && live.pairing?.transport ? { transport: live.pairing.transport } : {},
-		lastSeenAt: open ? now : Math.max(live.presence.lastPacketAt, live.lastSyncAt),
+		lastSeenAt: open ? now : Math.max(presenceSeenAt(live.presence), live.lastSyncAt),
 		...error ? { error } : {}
 	};
 }
@@ -17379,7 +18378,7 @@ var GroupEdits = class {
 			if (!takes(current) || (current.edit?.seq ?? 0) >= edit.e) return null;
 			const next = withEdit(current, {
 				seq: edit.e,
-				at: receivedTimestamp(edit.ts),
+				at: heardTime(edit.ts),
 				text: edit.m,
 				card: edit.sc
 			});
@@ -17876,6 +18875,14 @@ var POLL_IDLE_MS = 3e5;
 var RENEW_AFTER_MS = 3456e5;
 /** My pointer is published again this often while something is held, in case a relay forgot it. */
 var REPUBLISH_MS = 36e5;
+/**
+* A held item's address has this long to answer and be read whole, plus the time its declared size takes at the
+* slowest pace worth waiting for (64 KiB a second): about 21 s for a manifest, two and a half minutes for the largest
+* item. Past it the read is given up as any failed one is, and the next poll starts there again.
+*/
+var HOLD_FETCH_MS = 2e4;
+var HOLD_FETCH_BYTES_PER_S = 65536;
+var holdFetchTimeoutMs = (max) => HOLD_FETCH_MS + Math.ceil(max / HOLD_FETCH_BYTES_PER_S) * 1e3;
 var hex$2 = (bytes) => Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
 /**
 * Store-and-forward for away contacts (WISP 4xx, `hold/1`), on both ends of every chat that turned it
@@ -18054,7 +19061,7 @@ var HoldEngine = class {
 				name: heldName(storage.space, mailbox, seq),
 				bytes: item.bytes,
 				ts: item.timestamp,
-				expires: now + this.ttl(),
+				expires: now + Math.min(this.ttl(), HOLD_LIMITS.ttlMs - HOLD_DATED_BACK_MS),
 				state: "queued"
 			};
 			await this.save(linkId, {
@@ -18252,7 +19259,7 @@ var HoldEngine = class {
 		const now = this.now();
 		const held = hold.outbox.filter((e) => e.state === "held");
 		let manifestUrl = null;
-		const expires = now + HOLD_LIMITS.ttlMs;
+		const dated = now - HOLD_DATED_BACK_MS, expires = dated + HOLD_LIMITS.ttlMs;
 		if (held.length && storage && hold.mailbox) {
 			if (rewriteManifest || !hold.manifestSignedAt) {
 				const entries = [];
@@ -18268,7 +19275,7 @@ var HoldEngine = class {
 					mailbox: hold.mailbox,
 					seq: hold.pointerRev + 1,
 					id: `manifest-${hold.pointerRev + 1}`,
-					ts: now,
+					ts: dated,
 					kind: "manifest",
 					meta: { entries },
 					expires
@@ -18289,7 +19296,7 @@ var HoldEngine = class {
 		}
 		const pointer = {
 			rev: hold.pointerRev + 1,
-			issued: now,
+			issued: dated,
 			expires,
 			manifestUrl,
 			top: hold.outSeq,
@@ -18366,7 +19373,7 @@ var HoldEngine = class {
 			this.host.changed();
 			return;
 		}
-		const pointer = packet ? keys.readPointer(packet, now) : null;
+		const pointer = packet ? keys.readPointer(packet) : null;
 		if (!pointer) return;
 		let hold = this.state(linkId);
 		if (pointer.rev < hold.peerPointerRev) return;
@@ -18409,7 +19416,7 @@ var HoldEngine = class {
 			});
 			if (manifest.header.kind !== "manifest") throw new HoldRefusedError("format", "Not a manifest");
 			mailbox = manifest.header.mailbox;
-			entries = readManifest(manifest.header.meta).filter(([seq]) => seq > this.state(linkId).inSeq);
+			entries = readManifest(manifest.header.meta).filter(([seq]) => seq > this.state(linkId).inSeq).sort((a, b) => a[0] - b[0]);
 		} catch (error) {
 			if (error instanceof HoldRefusedError) {
 				await this.save(linkId, {
@@ -18527,11 +19534,33 @@ var HoldEngine = class {
 		}
 		this.host.changed();
 	}
-	/** A presigned address read whole, but never past `max` bytes: what the manifest declared, not what a server sends. */
+	/**
+	* A presigned address read whole, but never past `max` bytes: what the manifest declared, not what a server sends.
+	* And never past `holdFetchTimeoutMs(max)`: a request that hangs (no answer, or a body that stops) is aborted and
+	* fails as a network problem does. Before, one hung request held the pickup, and every chat's after it, for good.
+	*/
 	async fetchBytes(url, max) {
+		const abort = new AbortController();
+		let timer;
+		const late = new Promise((_, reject) => {
+			timer = setTimeout(() => {
+				reject(/* @__PURE__ */ new Error("The storage did not answer in time"));
+				abort.abort();
+			}, holdFetchTimeoutMs(max));
+		});
+		const read = this.readBytes(url, max, abort.signal);
+		read.catch(() => {});
+		try {
+			return await Promise.race([read, late]);
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+	async readBytes(url, max, signal) {
 		const response = await (this.host.fetch ?? ((...args) => fetch(...args)))(url, {
 			cache: "no-store",
-			credentials: "omit"
+			credentials: "omit",
+			signal
 		});
 		if (!response.ok) throw new Error(`The storage answered ${response.status}`);
 		if (Number(response.headers.get("content-length")) > max) throw new HoldRefusedError("size", "The held item is larger than the manifest said");
@@ -18541,6 +19570,9 @@ var HoldEngine = class {
 			return bytes;
 		}
 		const reader = response.body.getReader();
+		signal.addEventListener("abort", () => {
+			reader.cancel().catch(() => {});
+		}, { once: true });
 		const chunks = [];
 		let size = 0;
 		for (let next = await reader.read(); !next.done; next = await reader.read()) {
@@ -19376,7 +20408,7 @@ var ProfilePeek = class {
 			const keys = new HoldKeys(link, link.participationSeed, link.pairedPeerKey);
 			const packet = await transport.resolve(keys.peerAddress, { background: true });
 			const now = this.now(), hold = link.hold;
-			const pointer = packet ? keys.readPointer(packet, now) : null;
+			const pointer = packet ? keys.readPointer(packet) : null;
 			if (pointer && pointer.rev >= hold.peerPointerRev && pointer.expires > now && pointer.top > hold.inSeq) held = Math.min(pointer.count, pointer.top - hold.inSeq);
 		}
 		return {
@@ -19651,6 +20683,10 @@ var S3Store = class {
 *
 * Secrets are random, so there is no seed to restore from yet. `exportTokens`
 * is the backup, and balances are meant to stay pocket-money sized.
+*
+* Every swap is written down before the mint is asked (`PendingSwap`, or the payment intent of a reviewed payment),
+* with its blinded outputs and their secrets: the mint signs those outputs and no others, and its signatures can be
+* asked for again (NUT-09) at any time.
 */
 var UNIT$1 = "sat";
 var QUOTE_POLL_MS = 4e3;
@@ -19660,11 +20696,37 @@ var MAX_AMOUNT = 1e6;
 /** How long "Get test coins" waits for the test mint to mark its invoice paid before saying the coins come later. */
 var TEST_COINS_WAIT_MS = 3e4;
 var HISTORY_SHOWN = 100;
+/** How long before a mint that could not say which restored ecash is spent is asked again. */
+var RESTORED_POLL_MS = 6e4;
+/** How long before a mint that could not say where a swap stands is asked again. */
+var SWAP_POLL_MS = 3e4;
+/** The same, for a swap that holds nothing any more or whose mint cannot give signatures back: asked now and then. */
+var SWAP_SLOW_POLL_MS = 6e5;
+/** How long a swap whose inputs were given back is still asked about, in case the mint made it after all. */
+var SWAP_WATCH_MS = 36e5;
 function reviewedCashuFee(preview) {
 	const fee = preview.inputs.reduce((sum, proof) => sum + Amount.from(proof.amount).toNumber(), 0) - (preview.keepOutputs ?? []).reduce((sum, output) => sum + Amount.from(output.blindedMessage.amount).toNumber(), 0) - preview.amount.toNumber();
 	if (!Number.isSafeInteger(fee) || fee < 0) throw new Error("Invalid Cashu prepared fee");
 	return fee;
 }
+/**
+* The mint was asked for a swap and has not answered. The swap is written down: the wallet asks the mint where it
+* stands until it knows, then stores what it brought or frees what it held. Nothing is known to have failed.
+*/
+var SwapUnsettledError = class extends Error {
+	swap;
+	cause;
+	constructor(swap, cause) {
+		const host = new URL(swap.mint).host;
+		super(swap.kind === "receive" ? `${host} has not answered yet. The ecash is added to your wallet as soon as it does.` : `${host} has not answered yet. The payment was not made. The sats set aside for it return to your wallet a few minutes after the mint answers.`);
+		this.swap = swap;
+		this.cause = cause;
+		this.name = "SwapUnsettledError";
+	}
+};
+/** When a swap with no answer can no longer reach the mint: a request's longest life, and a margin after its last try. */
+var swapOverdueAt = (swap) => Math.max(swap.createdAt + CASHU_REQUEST_TIMEOUT_MS + SWAP_SETTLED_MS, (swap.attemptEndedAt ?? Number.POSITIVE_INFINITY) + SWAP_SETTLED_MS);
+var swapOf = (swap) => swap.swap;
 function normalizeMintUrl(input) {
 	let url;
 	try {
@@ -19695,6 +20757,7 @@ var toStored = (mint, p, reserved) => ({
 });
 /** The note of the ecash "Get test coins" brought (the engine plays its own sound for it). */
 var TEST_COINS_NOTE = "Test coins from the test mint";
+var swapId = () => `swap-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
 var walletTx = (mint, kind, amount, fee, note) => ({
 	id: `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`,
 	timestamp: Date.now(),
@@ -19728,8 +20791,13 @@ var CashuWallet = class {
 	locks = /* @__PURE__ */ new Map();
 	quoteTimer = null;
 	meltTimer = null;
+	restoredTimer = null;
+	swapTimer = null;
+	swapTimerAt = 0;
 	/** Per melt quote that ended unpaid: the sats the mint kept all the same (the fee of the split before the melt). */
 	failedFees = /* @__PURE__ */ new Map();
+	/** Melt quotes that ended unpaid with proofs the mint read spent: ecash spent somewhere else, said as such. */
+	spentAway = /* @__PURE__ */ new Set();
 	/**
 	* `getMints`: the mints of one network (the engine's default when none is named), primary first: balances,
 	* invoices, payments of that network's Cashu wallet. `getKnownMints`: every mint the user added, whatever its
@@ -19743,6 +20811,8 @@ var CashuWallet = class {
 	start() {
 		this.pollQuotes();
 		this.pollMelts();
+		this.checkRestored();
+		this.pollSwaps();
 		for (const mint of this.getKnownMints()) this.checkMint(mint).then(() => this.events.onChange(), () => {});
 	}
 	/** The Cashu wallet of one network: its mints and their balance. History is every network's, newest first. */
@@ -19756,13 +20826,57 @@ var CashuWallet = class {
 		}));
 		const all = await wrap((await store(STORES.walletTx, "readonly")).getAll());
 		all.sort((a, b) => b.timestamp - a.timestamp);
+		const here = new Set(mints.map((m) => m.url));
+		const swaps = (await wrap((await store(STORES.swaps, "readonly")).getAll())).filter((s) => here.has(s.mint) && !s.released && !s.finished);
+		const about = (s) => s.kind === "send" ? swapOf(s).inputs.reduce((sum, p) => sum + Number(p.amount), 0) : s.tx?.amount ?? 0;
+		const spentAway = new Set(swaps.filter((s) => s.stuck && s.kind === "send").flatMap((s) => swapOf(s).inputs.map((p) => p.secret)));
 		return {
 			mints,
 			balance: total(mints.map((m) => ({ amount: m.balance }))),
+			setAside: total(proofs.filter((p) => here.has(p.mint) && p.reserved && !spentAway.has(p.secret))),
+			openSwaps: swaps.length,
+			swapsAmount: total(swaps.map((s) => ({ amount: about(s) }))),
+			unconfirmed: total(swaps.filter((s) => s.stuck).map((s) => ({ amount: about(s) }))),
 			history: all.slice(0, HISTORY_SHOWN),
 			feesPaid: all.reduce((sum, tx) => sum + tx.fee, 0)
 		};
 	}
+	/**
+	* Ecash a profile restore brought back (`unchecked`) is a copy from when the backup was made. What was spent since
+	* (by the profile it was copied from, or by this one before it was restored) still counted in the balance, for good,
+	* and every payment that picked one of those proofs failed with the mint's "Token already spent". Each mint is asked
+	* once which of them it still reads unspent: a spent proof is dropped, an unspent one is checked for good, and one
+	* the mint holds pending, or a mint that cannot be asked, is asked again later.
+	*/
+	async checkRestored() {
+		if (this.restoredTimer) clearTimeout(this.restoredTimer);
+		this.restoredTimer = null;
+		const waiting = (p) => !!p.unchecked && !p.reserved;
+		let again = false, changed = false;
+		for (const mint of new Set((await this.allProofs()).filter(waiting).map((p) => p.mint))) try {
+			await this.locked(mint, async () => {
+				const proofs = (await this.allProofs()).filter((p) => p.mint === mint && waiting(p));
+				if (!proofs.length) return;
+				const states = await (await this.wallet(mint)).checkProofsStates(proofs);
+				if (states.length !== proofs.length) throw new Error("The mint answered for another number of proofs");
+				await transact([STORES.proofs], (stores) => {
+					proofs.forEach((proof, i) => {
+						const state = states[i]?.state;
+						if (state === "SPENT") stores[STORES.proofs].delete(proof.secret);
+						else if (state === "UNSPENT") {
+							const { unchecked: _checked, ...kept } = proof;
+							stores[STORES.proofs].put(kept);
+						} else again = true;
+					});
+				});
+				changed = true;
+			});
+		} catch {
+			again = true;
+		}
+		if (changed) this.events.onChange();
+		if (again) this.restoredTimer = setTimeout(() => void this.checkRestored(), RESTORED_POLL_MS);
+	}
 	/** Talks to the mint before it is added: a typo should not become a place to keep money. */
 	async checkMint(url) {
 		const normalized = normalizeMintUrl(url);
@@ -19923,12 +21037,16 @@ var CashuWallet = class {
 		const quote = await wrap((await store(STORES.quotes, "readonly")).get(id));
 		if (!quote || quote.issuedUnclaimed || quote.held) return null;
 		const wallet = await this.wallet(quote.mint);
-		const { state } = await wallet.checkMintQuoteBolt11(quote.quote);
+		const answer = await wallet.checkMintQuoteBolt11(quote.quote);
+		const { state } = answer;
 		if (state === "UNPAID") {
 			if (quote.expiresAt && quote.expiresAt + 6e4 < Date.now()) await wrap((await store(STORES.quotes, "readwrite")).delete(quote.quote));
 			return null;
 		}
+		const saved = quote.outputs?.map((o) => OutputData.deserialize(o));
 		if (state === "ISSUED") {
+			const issued = saved?.length ? await this.signedOutputs(wallet, saved) : void 0;
+			if (Array.isArray(issued)) return this.storeMinted(quote, issued);
 			console.warn(`[wallet] ${quote.mint} issued quote ${quote.quote} (${quote.amount} sats) but this wallet holds no ecash for it`);
 			await wrap((await store(STORES.quotes, "readwrite")).put({
 				...quote,
@@ -19936,11 +21054,31 @@ var CashuWallet = class {
 			}));
 			return null;
 		}
-		if (!quote.paid) await wrap((await store(STORES.quotes, "readwrite")).put({
+		const preview = await wallet.prepareMint("bolt11", quote.amount, {
+			...answer,
+			quote: quote.quote
+		});
+		if (saved) preview.outputData = saved;
+		const written = {
 			...quote,
-			paid: true
-		}));
-		const proofs = await wallet.mintProofsBolt11(quote.amount, quote.quote);
+			paid: true,
+			outputs: saved ? quote.outputs : preview.outputData.map((o) => OutputData.serialize(o))
+		};
+		if (!quote.paid || !saved) await wrap((await store(STORES.quotes, "readwrite")).put(written));
+		let proofs;
+		try {
+			proofs = await wallet.completeMint(preview);
+		} catch (error) {
+			if (saved && isMintOperationError(error) && (await wallet.checkMintQuoteBolt11(quote.quote).catch(() => null))?.state === "PAID") {
+				const { outputs: _refused, ...fresh } = written;
+				await wrap((await store(STORES.quotes, "readwrite")).put(fresh));
+			}
+			throw error;
+		}
+		return this.storeMinted(quote, proofs);
+	}
+	/** The ecash of a paid invoice goes in with its history line, in the transaction that drops the quote. */
+	async storeMinted(quote, proofs) {
 		const minted = sats(proofs);
 		const tx = walletTx(quote.mint, "lightning-in", minted, quote.amount - minted, quote.paymentId ? "Request paid over Lightning" : quote.testCoins ? TEST_COINS_NOTE : void 0);
 		await transact([
@@ -19977,24 +21115,24 @@ var CashuWallet = class {
 		for (const mint of candidates) {
 			if (await this.balanceAt(mint) < amount) continue;
 			return this.locked(mint, async () => {
-				const wallet = await this.wallet(mint);
-				const proofs = await this.proofsAt(mint);
-				const { keep, send } = await wallet.send(amount, asProofLike(proofs), { includeFees: true });
+				const { inputs, keep, send, swap } = await this.split(mint, amount, await this.proofsAt(mint));
 				const token = getEncodedToken({
 					mint,
 					proofs: send,
 					unit: UNIT$1
 				});
-				const spent = total(proofs) - sats(keep);
+				const spent = total(inputs) - sats(keep);
 				const tx = walletTx(mint, "ecash-out", amount, spent - amount, note);
 				const kept = outbox?.(token, mint);
 				await transact([
 					STORES.proofs,
 					STORES.walletTx,
+					STORES.swaps,
 					...kept ? [STORES.payments] : []
 				], (stores) => {
-					this.queueReplace(stores[STORES.proofs], mint, proofs, keep);
+					this.queueReplace(stores[STORES.proofs], mint, inputs, keep);
 					stores[STORES.walletTx].put(tx);
+					if (swap) stores[STORES.swaps].delete(swap.id);
 					if (kept) stores[STORES.payments].put(kept);
 				});
 				this.events.onChange();
@@ -20057,8 +21195,31 @@ var CashuWallet = class {
 		const keep = (prepared.swap.keepOutputs ?? []).map(OutputData.deserialize);
 		const send = (prepared.swap.sendOutputs ?? []).map(OutputData.deserialize);
 		const outputs = [...keep, ...send];
+		const restored = await this.restoreOutputs(wallet, outputs);
+		if (!Array.isArray(restored)) return void 0;
+		return this.finishReviewedCashu(review, prepared, restored.slice(0, keep.length), restored.slice(keep.length));
+	}
+	/**
+	* What the mint says of outputs that were written down before it was asked to sign them: the proofs they stand for
+	* when it signed them all, `none` when it answered that it signed none, and undefined when it has no way of saying
+	* (it does not restore, NUT-09, by its own info). Only an answer counts: a mint that cannot be reached, answers with
+	* an error or answers for some of the outputs throws, and is asked again later.
+	*/
+	async signedOutputs(wallet, outputs) {
+		if (!wallet.getMintInfo().isSupported(9).supported) return void 0;
+		const restored = await this.restoreOutputs(wallet, outputs);
+		if (restored === "some") throw new Error("The mint answered for some of the outputs");
+		return restored;
+	}
+	/**
+	* The mint's signatures for these exact outputs (NUT-09), as the proofs they stand for: all of them, `none`, or
+	* `some` (an answer that does not cover every output). It only reads what the mint already signed: nothing is
+	* swapped again.
+	*/
+	async restoreOutputs(wallet, outputs) {
 		const recovered = await wallet.mint.restore({ outputs: outputs.map((o) => o.blindedMessage) });
-		if (recovered.outputs.length !== outputs.length || recovered.signatures.length !== outputs.length) return void 0;
+		if (recovered.outputs.length === 0 && recovered.signatures.length === 0) return "none";
+		if (recovered.outputs.length !== outputs.length || recovered.signatures.length !== outputs.length) return "some";
 		const keys = (await wallet.mint.getKeys()).keysets;
 		const restored = [];
 		for (const output of outputs) {
@@ -20068,7 +21229,7 @@ var CashuWallet = class {
 			if (!signature || !key || signature.id !== output.blindedMessage.id || Amount.from(signature.amount).toString() !== Amount.from(output.blindedMessage.amount).toString()) throw new Error("Mint restore does not match reviewed outputs");
 			restored.push(output.toProof(signature, key));
 		}
-		return this.finishReviewedCashu(review, prepared, restored.slice(0, keep.length), restored.slice(keep.length));
+		return restored;
 	}
 	async finishReviewedCashu(review, prepared, keep, send) {
 		const token = getEncodedToken({
@@ -20125,6 +21286,72 @@ var CashuWallet = class {
 		const restored = await wallet.mint.restore({ outputs: outputs.map((o) => o.blindedMessage) });
 		return restored.signatures.length === 0 && restored.outputs.length === 0;
 	}
+	/**
+	* Whether a reviewed swap can never happen because its ecash was spent by something else: the mint answers that it
+	* signed none of its outputs (a successful NUT-09 answer, asked before and after), and reads an input spent, none
+	* pending. Read-only. A mint that does not restore cannot say, and the answer is no.
+	*/
+	async reviewedCashuSpentElsewhere(prepared) {
+		const preview = deserializeSwapPreview(prepared.swap);
+		if (!preview.inputs.length) return false;
+		const wallet = await this.wallet(prepared.mint);
+		const outputs = [...prepared.swap.keepOutputs ?? [], ...prepared.swap.sendOutputs ?? []].map(OutputData.deserialize);
+		if (await this.signedOutputs(wallet, outputs) !== "none") return false;
+		const states = await wallet.checkProofsStates(preview.inputs.map((p) => ({
+			secret: p.secret,
+			id: p.id
+		})));
+		if (states.length !== preview.inputs.length || states.some((s) => s.state === "PENDING") || !states.some((s) => s.state === "SPENT")) return false;
+		return await this.signedOutputs(wallet, outputs) === "none";
+	}
+	/**
+	* Ends a reviewed swap whose ecash was spent elsewhere: the inputs the mint reads spent leave the wallet, the others
+	* are free again, and the rest of the wallet's ecash at that mint is checked the same way. Idempotent.
+	*/
+	async dropReviewedCashu(prepared) {
+		const preview = deserializeSwapPreview(prepared.swap);
+		await this.locked(prepared.mint, async () => {
+			const states = await (await this.wallet(prepared.mint)).checkProofsStates(preview.inputs.map((p) => ({
+				secret: p.secret,
+				id: p.id
+			})));
+			if (states.length !== preview.inputs.length) throw new Error("The mint answered for another number of proofs");
+			const spent = new Set(preview.inputs.filter((_, i) => states[i]?.state === "SPENT").map((p) => p.secret));
+			await transact([STORES.proofs], (stores) => {
+				const proofs = stores[STORES.proofs];
+				for (const input of preview.inputs) {
+					const request = proofs.get(input.secret);
+					request.onsuccess = () => {
+						const proof = request.result;
+						if (!proof || !proof.reserved || proof.mint !== prepared.mint || proof.C !== input.C) return;
+						if (spent.has(input.secret)) {
+							proofs.delete(input.secret);
+							return;
+						}
+						const { reserved: _released, ...free } = proof;
+						proofs.put(free);
+					};
+				}
+			});
+		});
+		await this.recheck(prepared.mint);
+		this.events.onChange();
+	}
+	/**
+	* A proof of this wallet read spent when nothing here spent it: its ecash is in use somewhere else too. Every other
+	* free proof at that mint is asked about once (`checkRestored`), so the balance becomes what the mint still holds
+	* instead of one payment after another finding out.
+	*/
+	async recheck(mint) {
+		const free = (await this.allProofs()).filter((p) => p.mint === mint && !p.reserved && !p.unchecked);
+		if (free.length > 0) await transact([STORES.proofs], (stores) => {
+			for (const p of free) stores[STORES.proofs].put({
+				...p,
+				unchecked: true
+			});
+		});
+		await this.checkRestored();
+	}
 	/** Gives back the inputs a reviewed swap reserved, once the mint proved it never happened. Idempotent. */
 	async releaseReviewedCashu(prepared) {
 		const preview = deserializeSwapPreview(prepared.swap);
@@ -20144,6 +21371,13 @@ var CashuWallet = class {
 		});
 		this.events.onChange();
 	}
+	/**
+	* Whether the ecash of a reviewed payment came back to this wallet (Take it back, or a refusal). Its proofs then read
+	* SPENT at the mint because this wallet redeemed them, not the contact.
+	*/
+	async reviewedCashuTakenBack(id) {
+		return (await wrap((await store(STORES.payments, "readonly")).get(id)))?.state === "reclaimed";
+	}
 	async reviewedCashuSpent(prepared) {
 		const outputs = (prepared.swap.sendOutputs ?? []).map(OutputData.deserialize);
 		const states = await (await this.wallet(prepared.mint)).checkProofsStates(outputs.map((o) => ({
@@ -20199,18 +21433,40 @@ var CashuWallet = class {
 		if (addTestMint && !this.getKnownMints().includes(mint) && isTestMint(mint)) await this.events.onTestMintNeeded(mint);
 		if (!this.getKnownMints().includes(mint)) throw new Error(`Ecash from ${new URL(mint).hostname} is not accepted`);
 		return this.locked(mint, async () => {
-			const proofs = await (await this.wallet(mint)).receive(token);
-			const credited = sats(proofs);
-			const tx = walletTx(mint, kind, credited, Math.max(0, faceValue - credited), note);
-			await transact([
-				STORES.proofs,
-				STORES.walletTx,
-				...payment ? [STORES.payments] : []
-			], (stores) => {
-				for (const p of proofs) stores[STORES.proofs].put(toStored(mint, p));
-				stores[STORES.walletTx].put(tx);
-				if (payment) stores[STORES.payments].put(payment(credited, mint));
+			const records = (credited) => ({
+				tx: walletTx(mint, kind, credited, Math.max(0, faceValue - credited), note),
+				...payment ? { payment: payment(credited, mint) } : {}
 			});
+			let swap = (await this.swapsAt(mint)).find((s) => s.kind === "receive" && s.token === token);
+			if (swap?.finished) return {
+				amount: swap.tx?.amount ?? 0,
+				mint
+			};
+			if (!swap) {
+				const preview = await (await this.wallet(mint)).prepareSwapToReceive(token);
+				swap = {
+					id: swapId(),
+					mint,
+					kind: "receive",
+					swap: serializeSwapPreview(preview),
+					createdAt: Date.now(),
+					token,
+					...records(preview.amount.toNumber())
+				};
+				await wrap((await store(STORES.swaps, "readwrite")).put(swap));
+			}
+			const { keep } = await this.completeSwap(swap);
+			const credited = sats(keep);
+			if (swap.tx && credited !== swap.tx.amount) swap = {
+				...swap,
+				...records(credited),
+				tx: {
+					...records(credited).tx,
+					id: swap.tx.id,
+					timestamp: swap.tx.timestamp
+				}
+			};
+			await this.finishSwap(swap, keep, [], false);
 			this.events.onChange();
 			return {
 				amount: credited,
@@ -20218,6 +21474,334 @@ var CashuWallet = class {
 			};
 		});
 	}
+	/**
+	* Splits `amount`, with the fee its receiver will pay to redeem it, out of `proofs`. Coins that add up exactly need
+	* no mint. Otherwise it is a swap: written down, with its inputs reserved, before the mint is asked. The caller
+	* stores the result in one transaction: `inputs` out, `keep` in, `send` where it goes, and `swap` deleted.
+	* Runs under the mint's lock.
+	*/
+	async split(mint, amount, proofs) {
+		const wallet = await this.wallet(mint);
+		const among = (chosen) => {
+			const secrets = new Set(chosen.map((p) => p.secret));
+			return proofs.filter((p) => secrets.has(p.secret));
+		};
+		try {
+			const { send } = wallet.sendOffline(amount, asProofLike(proofs), {
+				includeFees: true,
+				exactMatch: true
+			});
+			if (send.length > 0 && sats(send) === amount + wallet.getFeesForProofs(send).toNumber()) return {
+				inputs: among(send),
+				keep: [],
+				send
+			};
+		} catch {}
+		const preview = await wallet.prepareSwapToSend(amount, asProofLike(proofs), { includeFees: true });
+		const swap = {
+			id: swapId(),
+			mint,
+			kind: "send",
+			swap: serializeSwapPreview(preview),
+			createdAt: Date.now()
+		};
+		const inputs = among(preview.inputs);
+		await transact([STORES.proofs, STORES.swaps], (stores) => {
+			for (const p of inputs) stores[STORES.proofs].put({
+				...p,
+				reserved: true
+			});
+			stores[STORES.swaps].put(swap);
+		});
+		const { keep, send } = await this.completeSwap(swap);
+		return {
+			inputs,
+			keep,
+			send,
+			swap
+		};
+	}
+	/**
+	* Sends a written-down swap to the mint: always the saved one, so a second try asks for the same outputs. When the
+	* answer is missed the mint is asked what it did, and its word decides: the outputs it signed are the result, as the
+	* answer would have been; a swap it says it never made is undone and the failure is thrown; and for as long as the
+	* swap stays written down nothing is known to have failed, whatever the mint's words were (`SwapUnsettledError`):
+	* `pollSwaps` settles it. Runs under the mint's lock.
+	*/
+	async completeSwap(swap) {
+		try {
+			return await (await this.wallet(swap.mint)).completeSwap(deserializeSwapPreview(swapOf(swap)));
+		} catch (error) {
+			const refused = isMintOperationError(error) && swap.attemptEndedAt === void 0;
+			const ended = {
+				...swap,
+				attemptEndedAt: Date.now()
+			};
+			await (async () => wrap((await store(STORES.swaps, "readwrite")).put(ended)))().catch(() => {});
+			const outcome = await this.swapOutcome(ended, refused).catch(() => ({ state: "open" }));
+			if (outcome.state === "done") return outcome;
+			if (outcome.state === "never" && outcome.final) {
+				await this.dropSwap(ended, outcome.gone);
+				throw outcome.gone.size > 0 ? Object.assign(engineError("ecashAlreadySpent"), { cause: error }) : error;
+			}
+			this.swapsAgainIn(SWAP_POLL_MS);
+			this.events.onChange();
+			throw new SwapUnsettledError(ended, error);
+		}
+	}
+	/**
+	* Asks the mint where a written-down swap stands. It only asks: nothing is sent again, nothing is stored.
+	* `refused`: the mint refused the only request ever made for this swap, so no request of it is still on its way.
+	* Throws when the mint cannot be asked, or answers with an error: only its answers count.
+	*/
+	async swapOutcome(swap, refused = false) {
+		const wallet = await this.wallet(swap.mint);
+		const saved = swapOf(swap);
+		const keep = (saved.keepOutputs ?? []).map(OutputData.deserialize);
+		const send = (saved.sendOutputs ?? []).map(OutputData.deserialize);
+		const signed = async () => {
+			const proofs = await this.signedOutputs(wallet, [...keep, ...send]);
+			return Array.isArray(proofs) ? {
+				state: "done",
+				keep: proofs.slice(0, keep.length),
+				send: proofs.slice(keep.length)
+			} : proofs;
+		};
+		const first = await signed();
+		if (first && first !== "none") return first;
+		const states = await wallet.checkProofsStates(saved.inputs.map((p) => ({
+			secret: p.secret,
+			id: p.id
+		})));
+		if (states.length !== saved.inputs.length) throw new Error("The mint answered for another number of proofs");
+		if (states.some((s) => s.state === "PENDING")) return { state: "open" };
+		const gone = new Set(saved.inputs.filter((_, i) => states[i]?.state === "SPENT").map((p) => p.secret));
+		if (gone.size > 0) {
+			const second = await signed();
+			if (second && second !== "none") return second;
+			if (second === "none" || refused) return {
+				state: "never",
+				gone,
+				final: true
+			};
+			return {
+				state: "open",
+				slow: true
+			};
+		}
+		if (refused) return {
+			state: "never",
+			gone,
+			final: true
+		};
+		if (Date.now() >= swapOverdueAt(swap)) return {
+			state: "never",
+			gone,
+			final: false
+		};
+		return {
+			state: "open",
+			idle: !!first
+		};
+	}
+	/**
+	* Stores what a swap brought, in one transaction that reads the swap first: a swap still written down was never
+	* stored, and one stored is never stored again, whoever else works on this database. A redeem brings its ecash with
+	* its history line and its payment record. A split finished here was not finished by its caller (the payment it was
+	* for is over): everything it made is the wallet's. `late`: after the call that made it was over; a swap with a
+	* payment then stays, marked `finished`, until the chat has been told (`tellSwap`). Returns whether it stored.
+	*/
+	async finishSwap(swap, keep, send, late) {
+		const secrets = new Set(swap.kind === "send" ? swapOf(swap).inputs.map((p) => p.secret) : []);
+		const inputs = (await this.allProofs()).filter((p) => p.mint === swap.mint && secrets.has(p.secret));
+		const lost = swap.kind === "send" ? swapOf(swap).inputs.reduce((sum, p) => sum + Number(p.amount), 0) - sats(keep) - sats(send) : 0;
+		let stored = false;
+		await transact([
+			STORES.proofs,
+			STORES.swaps,
+			STORES.walletTx,
+			...swap.payment ? [STORES.payments] : []
+		], (stores) => {
+			const current = stores[STORES.swaps].get(swap.id);
+			current.onsuccess = () => {
+				const kept = current.result;
+				if (!kept || kept.finished) return;
+				stored = true;
+				for (const p of inputs) stores[STORES.proofs].delete(p.secret);
+				for (const p of [...keep, ...send]) stores[STORES.proofs].put({
+					...toStored(swap.mint, p),
+					...swap.restored ? { unchecked: true } : {}
+				});
+				if (swap.tx) stores[STORES.walletTx].put(swap.tx);
+				if (lost > 0) stores[STORES.walletTx].put({
+					...walletTx(swap.mint, "fee", 0, lost, "A payment was not sent"),
+					id: swap.id
+				});
+				if (swap.payment) stores[STORES.payments].put(swap.payment);
+				if (late && swap.payment) stores[STORES.swaps].put({
+					...kept,
+					finished: true
+				});
+				else stores[STORES.swaps].delete(swap.id);
+			};
+		});
+		if (stored && swap.restored) this.checkRestored();
+		return stored;
+	}
+	/**
+	* The mint never made this swap. The inputs it held are free again, less any the mint reads spent. `watch`: it is
+	* only overdue, so it stays written down, marked `released`, and is asked about for a while longer: should the mint
+	* have made it after all, what it made is still recovered.
+	*/
+	async dropSwap(swap, gone, watch = false) {
+		const inputs = swap.kind === "send" && !swap.released ? await this.storedInputs(swap) : [];
+		if (gone.size > 0 && inputs.length > 0) console.warn(`[wallet] ${gone.size} proofs of a swap at ${swap.mint} that never happened are spent`);
+		await transact([STORES.proofs, STORES.swaps], (stores) => {
+			for (const p of inputs) if (gone.has(p.secret)) stores[STORES.proofs].delete(p.secret);
+			else {
+				const { reserved: _released, ...free } = p;
+				stores[STORES.proofs].put(free);
+			}
+			if (watch) stores[STORES.swaps].put({
+				...swap,
+				released: true
+			});
+			else stores[STORES.swaps].delete(swap.id);
+		});
+		if (gone.size > 0 && inputs.length > 0) this.recheck(swap.mint).catch(() => {});
+	}
+	/** The proofs a split reserved, as they are stored now. */
+	async storedInputs(swap) {
+		const secrets = new Set(swapOf(swap).inputs.map((p) => p.secret));
+		return (await this.allProofs()).filter((p) => p.mint === swap.mint && p.reserved && secrets.has(p.secret));
+	}
+	async swapsAt(mint) {
+		return (await wrap((await store(STORES.swaps, "readonly")).getAll())).filter((s) => s.mint === mint);
+	}
+	/** Says what became of a swap to whoever follows it (the chat its payment is in), and waits for it to be taken in. */
+	async tellSwap(swap, done) {
+		try {
+			await this.events.onSwapSettled?.(swap, done);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	swapsAgainIn(ms) {
+		if (this.swapTimer && this.swapTimerAt <= Date.now() + ms) return;
+		if (this.swapTimer) clearTimeout(this.swapTimer);
+		this.swapTimerAt = Date.now() + ms;
+		this.swapTimer = setTimeout(() => void this.pollSwaps(), ms);
+	}
+	/**
+	* Swaps still written down: the app closed while the mint was being asked, or the mint did not answer. Each mint is
+	* asked where its own stand, under its lock. A swap it made is stored as its answer would have been; one it says it
+	* never made is undone; one that is only overdue gives its inputs back and stays watched; one it cannot speak for
+	* is asked about again. `mints`: only these mints', once, now.
+	*/
+	/** Asks these mints about their open swaps now (before a wallet's removal is shown or refused). */
+	settleSwaps(mints) {
+		return this.pollSwaps(mints);
+	}
+	async pollSwaps(mints) {
+		if (!mints) {
+			if (this.swapTimer) clearTimeout(this.swapTimer);
+			this.swapTimer = null;
+		}
+		const open = (await wrap((await store(STORES.swaps, "readonly")).getAll())).filter((s) => !mints || mints.includes(s.mint));
+		let again = 0;
+		const later = (ms) => {
+			again = again ? Math.min(again, ms) : ms;
+		};
+		for (const mint of new Set(open.map((s) => s.mint))) await this.locked(mint, async () => {
+			for (let swap of await this.swapsAt(mint)) try {
+				if (swap.finished) {
+					if (await this.tellSwap(swap, true)) await wrap((await store(STORES.swaps, "readwrite")).delete(swap.id));
+					else later(SWAP_POLL_MS);
+					continue;
+				}
+				if (swap.askAt && Date.now() < swap.askAt && !mints) {
+					later(swap.askAt - Date.now());
+					continue;
+				}
+				if (swap.attemptEndedAt === void 0) {
+					swap = {
+						...swap,
+						attemptEndedAt: Date.now()
+					};
+					await wrap((await store(STORES.swaps, "readwrite")).put(swap));
+				}
+				const outcome = await this.swapOutcome(swap);
+				if (outcome.state === "open") {
+					if (swap.released && Date.now() >= swap.createdAt + SWAP_WATCH_MS) {
+						await this.dropSwap(swap, /* @__PURE__ */ new Set());
+						continue;
+					}
+					if (outcome.slow) {
+						const stuck = (swap.stuck ?? 0) + 1;
+						const wait = stuck <= 6 ? SWAP_SLOW_POLL_MS : stuck <= 30 ? 36e5 : 864e5;
+						await wrap((await store(STORES.swaps, "readwrite")).put({
+							...swap,
+							stuck,
+							askAt: Date.now() + wait
+						}));
+						if (stuck === 1) this.events.onChange();
+						later(wait);
+					} else if (outcome.idle && swap.kind === "receive" && !swap.released) try {
+						const { keep } = await (await this.wallet(mint)).completeSwap(deserializeSwapPreview(swapOf(swap)));
+						if (await this.finishSwap(swap, keep, [], true)) {
+							const told = await this.tellSwap(swap, true);
+							if (swap.payment && told) await wrap((await store(STORES.swaps, "readwrite")).delete(swap.id));
+							else if (swap.payment) later(SWAP_POLL_MS);
+							this.events.onChange();
+						}
+					} catch (error) {
+						swap = {
+							...swap,
+							attemptEndedAt: Date.now()
+						};
+						await wrap((await store(STORES.swaps, "readwrite")).put(swap));
+						const refusal = isMintOperationError(error) ? await this.swapOutcome(swap, true).catch(() => void 0) : void 0;
+						if (refusal?.state === "done") {
+							if (await this.finishSwap(swap, refusal.keep, refusal.send, true)) {
+								const told = await this.tellSwap(swap, true);
+								if (swap.payment && told) await wrap((await store(STORES.swaps, "readwrite")).delete(swap.id));
+							}
+							this.events.onChange();
+						} else if (refusal?.state === "never") {
+							await this.dropSwap(swap, refusal.gone);
+							await this.tellSwap(swap, false);
+							this.events.onChange();
+						} else later(SWAP_POLL_MS);
+					}
+					else later(swap.released ? SWAP_SLOW_POLL_MS : SWAP_POLL_MS);
+					continue;
+				}
+				if (outcome.state === "done") {
+					if (await this.finishSwap(swap, outcome.keep, outcome.send, true)) {
+						const told = await this.tellSwap(swap, true);
+						if (swap.payment && told) await wrap((await store(STORES.swaps, "readwrite")).delete(swap.id));
+						else if (swap.payment) later(SWAP_POLL_MS);
+					}
+				} else if (swap.released) {
+					if (outcome.final || Date.now() >= swap.createdAt + SWAP_WATCH_MS) await this.dropSwap(swap, outcome.gone);
+					else later(SWAP_SLOW_POLL_MS);
+					continue;
+				} else {
+					await this.dropSwap(swap, outcome.gone, !outcome.final);
+					await this.tellSwap(swap, false);
+					if (!outcome.final) later(SWAP_SLOW_POLL_MS);
+				}
+				this.events.onChange();
+			} catch {
+				if (swap.released && Date.now() >= swap.createdAt + SWAP_WATCH_MS) await this.dropSwap(swap, /* @__PURE__ */ new Set()).catch(() => {});
+				else later(swap.released ? SWAP_SLOW_POLL_MS : SWAP_POLL_MS);
+			}
+		}).catch(() => {
+			later(SWAP_POLL_MS);
+		});
+		if (again && !mints) this.swapsAgainIn(again);
+	}
 	/** What paying this invoice would cost, from the first mint that can afford it. */
 	async quoteInvoice(invoice, network) {
 		let lastError = /* @__PURE__ */ new Error("Add a mint in Settings first");
@@ -20248,7 +21832,8 @@ var CashuWallet = class {
 	/**
 	* Pays a melt quote. True once paid; false while the mint holds the payment pending, in which case its
 	* proofs stay reserved and the wallet keeps asking until the mint settles it (`onMeltResolved`).
-	* Throws only when the sats never left the wallet or are known to be back in it.
+	* Throws only when the sats never left the wallet or are known to be back in it, or when the split before the payment
+	* has no answer yet (`SwapUnsettledError`): the payment was not made, and the split is settled by `pollSwaps`.
 	*/
 	async payQuote(quoteId, mint, note, paymentId) {
 		try {
@@ -20265,13 +21850,15 @@ var CashuWallet = class {
 		const quote = await wallet.checkMeltQuoteBolt11(quoteId);
 		if ((await wrap((await store(STORES.melts, "readonly")).getAll())).some((m) => m.quote === quote.quote || m.request === quote.request)) throw new Error("This invoice is already being paid");
 		const needed = quote.amount.toNumber() + quote.fee_reserve.toNumber();
-		const proofs = await this.proofsAt(mint);
-		const { keep, send } = await wallet.send(needed, asProofLike(proofs), { includeFees: true });
+		const { inputs, keep, send, swap } = await this.split(mint, needed, await this.proofsAt(mint));
 		let preview;
 		try {
 			preview = await wallet.prepareMelt("bolt11", quote, send);
 		} catch (error) {
-			await this.replaceProofs(mint, proofs, [...keep, ...send]);
+			await transact([STORES.proofs, STORES.swaps], (stores) => {
+				this.queueReplace(stores[STORES.proofs], mint, inputs, [...keep, ...send]);
+				if (swap) stores[STORES.swaps].delete(swap.id);
+			});
 			throw error;
 		}
 		const melt = {
@@ -20280,16 +21867,21 @@ var CashuWallet = class {
 			request: quote.request,
 			amount: quote.amount.toNumber(),
 			secrets: send.map((p) => p.secret),
-			outlay: total(proofs) - sats(keep),
+			outlay: total(inputs) - sats(keep),
 			outputs: preview.outputData.map((o) => OutputData.serialize(o)),
 			note: note?.slice(0, 140),
 			paymentId,
 			createdAt: Date.now()
 		};
-		await transact([STORES.proofs, STORES.melts], (stores) => {
-			this.queueReplace(stores[STORES.proofs], mint, proofs, keep);
+		await transact([
+			STORES.proofs,
+			STORES.melts,
+			STORES.swaps
+		], (stores) => {
+			this.queueReplace(stores[STORES.proofs], mint, inputs, keep);
 			for (const p of send) stores[STORES.proofs].put(toStored(mint, p, true));
 			stores[STORES.melts].put(melt);
+			if (swap) stores[STORES.swaps].delete(swap.id);
 		});
 		let result;
 		try {
@@ -20299,6 +21891,7 @@ var CashuWallet = class {
 			const outcome = await this.settleMelt(melt).catch(() => "pending");
 			if (outcome === "unpaid") {
 				const lost = this.takeFailedFee(melt.quote);
+				if (this.spentAway.delete(melt.quote)) throw Object.assign(engineError("ecashAlreadySpent"), { cause: error });
 				if (lost > 0) throw Object.assign(/* @__PURE__ */ new Error(`${error instanceof Error ? error.message : String(error)} ${backInWallet(lost)}`), { cause: error });
 				throw error;
 			}
@@ -20310,6 +21903,13 @@ var CashuWallet = class {
 		}
 		return this.settleMelt(melt).catch(() => "pending");
 	}
+	/**
+	* Whether a Lightning payment of this invoice is written down as in flight. A melt is written before the mint sees
+	* its proofs, and `pollMelts` settles and reports it: an invoice with none never reached the mint's melt, or is done.
+	*/
+	async meltInFlight(invoice) {
+		return (await wrap((await store(STORES.melts, "readonly")).getAll())).some((m) => m.request === invoice);
+	}
 	/** Lightning payments left pending, asked about again until the mint settles each one. */
 	async pollMelts() {
 		if (this.meltTimer) clearTimeout(this.meltTimer);
@@ -20322,6 +21922,7 @@ var CashuWallet = class {
 			});
 			if (outcome === "paid" || outcome === "unpaid") {
 				this.takeFailedFee(melt.quote);
+				this.spentAway.delete(melt.quote);
 				this.events.onMeltResolved(melt, outcome === "paid");
 				this.events.onChange();
 			}
@@ -20356,7 +21957,7 @@ var CashuWallet = class {
 		if (states.some((s) => s.state === "PENDING")) return "pending";
 		const spent = new Set(inputs.filter((_, i) => states[i]?.state === "SPENT").map((p) => p.secret));
 		if (spent.size > 0) console.warn(`[wallet] melt ${melt.quote} is unpaid, yet ${spent.size} of its proofs are spent`);
-		const lost = melt.outlay - inputs.filter((p) => !spent.has(p.secret)).reduce((sum, p) => sum + p.amount, 0);
+		const lost = melt.outlay - inputs.reduce((sum, p) => sum + p.amount, 0);
 		await transact([
 			STORES.proofs,
 			STORES.melts,
@@ -20371,6 +21972,10 @@ var CashuWallet = class {
 			if (lost > 0) stores[STORES.walletTx].put(walletTx(melt.mint, "fee", 0, lost, melt.note ? `Payment failed: ${melt.note}` : "A Lightning payment failed"));
 		});
 		if (lost > 0) this.failedFees.set(melt.quote, lost);
+		if (spent.size > 0) {
+			this.spentAway.add(melt.quote);
+			this.recheck(melt.mint).catch(() => {});
+		}
 		return "unpaid";
 	}
 	/** The fee a failed melt cost, once: for the words that say it failed. */
@@ -20399,14 +22004,22 @@ var CashuWallet = class {
 	* and every invoice of theirs are deleted. A Lightning payment still in flight from one of them is not cut off: the
 	* removal is refused until it settles.
 	*/
-	async forget(mints) {
+	async forget(mints, acceptLoss = false) {
 		const at = new Set(mints);
 		if ((await wrap((await store(STORES.melts, "readonly")).getAll())).some((m) => at.has(m.mint))) throw new Error("A Lightning payment from this wallet is still in flight: wait for it to settle, then remove the wallet.");
+		await this.pollSwaps(mints).catch(() => {});
+		if ((await wrap((await store(STORES.swaps, "readonly")).getAll())).filter((s) => at.has(s.mint) && !s.released).length > 0 && !acceptLoss) throw new Error("An exchange of ecash with this wallet's mint is not finished yet: wait for the mint to answer, or confirm that what it would bring is lost to remove the wallet.");
 		const proofs = (await this.allProofs()).filter((p) => at.has(p.mint));
 		const quotes = (await wrap((await store(STORES.quotes, "readonly")).getAll())).filter((q) => at.has(q.mint));
-		await transact([STORES.proofs, STORES.quotes], (stores) => {
+		const swaps = (await wrap((await store(STORES.swaps, "readonly")).getAll())).filter((s) => at.has(s.mint));
+		await transact([
+			STORES.proofs,
+			STORES.quotes,
+			STORES.swaps
+		], (stores) => {
 			for (const p of proofs) stores[STORES.proofs].delete(p.secret);
 			for (const q of quotes) stores[STORES.quotes].delete(q.quote);
+			for (const s of swaps) stores[STORES.swaps].delete(s.id);
 		});
 		for (const mint of mints) {
 			this.wallets.delete(mint);
@@ -20462,10 +22075,7 @@ var CashuWallet = class {
 	async proofsAt(mint) {
 		return (await this.allProofs()).filter((p) => p.mint === mint && !p.reserved);
 	}
-	/** After a swap: the inputs are spent, `keep` is what came back to us. One transaction, so it is all or nothing. */
-	async replaceProofs(mint, inputs, keep) {
-		await transact([STORES.proofs], (stores) => this.queueReplace(stores[STORES.proofs], mint, inputs, keep));
-	}
+	/** After a swap: the inputs are spent, `keep` is what came back to us. Queued in the caller's transaction: all or nothing. */
 	queueReplace(proofStore, mint, inputs, keep) {
 		const kept = new Set(keep.map((p) => p.secret));
 		for (const p of inputs) if (!kept.has(p.secret)) proofStore.delete(p.secret);
@@ -21147,7 +22757,11 @@ var PaymentDesk = class {
 		}
 		if (!payment?.token || payment.direction !== "out") throw new Error("Nothing to reclaim");
 		try {
-			await this.wallet.receiveToken(payment.token, "reclaimed", payment.memo);
+			await this.wallet.receiveToken(payment.token, "reclaimed", payment.memo, { payment: () => ({
+				...this.current(payment),
+				state: "reclaimed",
+				token: void 0
+			}) });
 			await this.save({
 				...this.current(payment),
 				state: "reclaimed",
@@ -21458,31 +23072,18 @@ var PaymentDesk = class {
 				addTestMint: true,
 				payment: record
 			});
-			await this.save(record(amount, mint));
-			const request = payment.requestId ? this.payments.get(payment.requestId) : void 0;
-			if (request?.kind === "request" && request.direction === "out" && this.owns(request, linkId) && request.state === "pending" && amount >= request.amount && (request.mints ?? []).includes(mint) && (!isWorthlessMint(mint) || (request.mints ?? []).every(isWorthlessMint))) {
-				if (request.group) await this.settleRequest(request, { mint });
-				else await this.save({
-					...request,
-					state: "settled",
-					mint
+			await this.creditCashu(record(amount, mint), link);
+		} catch (error) {
+			if (error instanceof SwapUnsettledError) return;
+			const settled = this.payments.get(payment.id);
+			if (settled && settled.linkId === linkId && settled.direction === "in" && settled.kind === "payment" && settled.state === "settled") {
+				link?.sendPaymentResult({
+					id: payment.id,
+					ok: true,
+					credited: String(settled.amount)
 				});
+				return;
 			}
-			await this.host.storeMessage({
-				linkId,
-				id: `peer_${payment.timestamp}`,
-				text: `⚡ ${amount.toLocaleString()} ${isWorthlessMint(mint) ? "test sats" : "sats"}`,
-				sender: "peer",
-				timestamp: payment.timestamp,
-				via: "datalink",
-				paymentId: payment.id
-			});
-			link?.sendPaymentResult({
-				id: payment.id,
-				ok: true,
-				credited: String(amount)
-			});
-		} catch (error) {
 			const reason = error instanceof Error ? error.message : String(error);
 			link?.sendPaymentResult({
 				id: payment.id,
@@ -21502,6 +23103,61 @@ var PaymentDesk = class {
 			} catch {}
 		}
 	}
+	/**
+	* A contact's ecash is in the wallet, and its record was written with it in the same transaction: the request it
+	* pays is settled, the chat shows it, and the contact is told.
+	*/
+	async creditCashu(record, link) {
+		const { linkId, amount } = record;
+		const mint = record.mint;
+		await this.save(record);
+		const request = record.requestId ? this.payments.get(record.requestId) : void 0;
+		if (request?.kind === "request" && request.direction === "out" && this.owns(request, linkId) && request.state === "pending" && amount >= request.amount && (request.mints ?? []).includes(mint) && (!isWorthlessMint(mint) || (request.mints ?? []).every(isWorthlessMint))) {
+			if (request.group) await this.settleRequest(request, { mint });
+			else await this.save({
+				...request,
+				state: "settled",
+				mint
+			});
+		}
+		await this.host.storeMessage({
+			linkId,
+			id: `peer_${record.createdAt}`,
+			text: `⚡ ${amount.toLocaleString()} ${isWorthlessMint(mint) ? "test sats" : "sats"}`,
+			sender: "peer",
+			timestamp: record.createdAt,
+			via: "datalink",
+			paymentId: record.id
+		});
+		link?.sendPaymentResult({
+			id: record.id,
+			ok: true,
+			credited: String(amount)
+		});
+	}
+	/**
+	* A redeem the mint had not answered is settled, after the call that made it was over (`CashuWallet.pollSwaps`).
+	* Done: the ecash and its payment record are already stored, and the rest follows as if the answer had come in time.
+	* Not done: the mint never made it, so a contact's ecash is still the contact's, and it is told so.
+	*/
+	async onSwapSettled(swap, done) {
+		const record = swap.payment;
+		if (!record) return;
+		const link = this.host.getLink(record.linkId);
+		if (record.direction === "out") {
+			if (done) {
+				this.payments.set(record.id, record);
+				this.host.onChange();
+			}
+			return;
+		}
+		if (done) await this.creditCashu(record, link);
+		else if (!this.payments.has(record.id)) link?.sendPaymentResult({
+			id: record.id,
+			ok: false,
+			error: "The mint did not confirm the ecash"
+		});
+	}
 	async onPaymentResult(linkId, result) {
 		const payment = this.find(linkId, result.id);
 		if (payment?.target?.method === "fedimint" && payment.linkId === linkId && payment.direction === "out" && payment.kind === "payment") {
@@ -23019,6 +24675,20 @@ function knockCue(before, after) {
 }
 /** A group's own line that says I made it or joined it (not someone else joining). */
 var groupCue = (message) => message.event === "created" || message.event === "joined" && !message.member ? "group" : void 0;
+/**
+* When a contact's message was written, by this device's clock. The time it says is its sender's clock, and a clock
+* behind this one makes everything it writes look old: a reply to what I just wrote read as written minutes before
+* my message, a late catch-up, and nothing rang. `leads`: for the contact's latest messages on the live session, how
+* far the time each said was from when it came (`sentAt - timestamp`). A message cannot come before it is written, so
+* the one that came quickest says how far behind the contact's clock is, and every time it says is read that much
+* later. A clock ahead needs nothing: a time still to come is taken as when the message came (as `shownTime` does).
+* With no live message to tell the clock by, the time is taken as said.
+*/
+function writtenAt(message, leads) {
+	if (message.sentAt === void 0) return message.timestamp;
+	const behind = leads?.length ? Math.min(0, Math.max(...leads)) : 0;
+	return Math.min(message.timestamp, message.sentAt - behind);
+}
 var JOIN_NOTICE = /^👋 (?:.+ )?joined$/;
 /** What a newly stored row says, or null when it is quiet. `type`: "message" for the contact's, "sent" for mine. */
 function messageAttention(type, message, { startedAt, newest, now }) {
@@ -23205,7 +24875,11 @@ var WalletSetup = class {
 * The wasm (about 1 MB gzip) loads on the first chat that starts an endpoint,
 * never on the app's first load.
 */
-/** n0's public relays, the same ones the Desktop's Iroh homes on by default. */
+/**
+* n0's public relays, the same ones the Desktop's Iroh homes on by default. Iroh itself names them with the trailing
+* dot of a full domain name (`use1-1.relay.n0.iroh.link.`), and compares relay URLs as text; here they have none,
+* because WebKit opens no host name that ends in a dot. `BROWSER_SPELLING` is what keeps the two one relay.
+*/
 var DEFAULT_IROH_RELAYS = [
 	"https://use1-1.relay.n0.iroh.link/",
 	"https://euc1-1.relay.n0.iroh.link/",
@@ -23213,6 +24887,12 @@ var DEFAULT_IROH_RELAYS = [
 	"https://usw1-1.relay.n0.iroh.link/"
 ];
 /**
+* The spelling of every relay URL handed to the wasm Iroh (`irohRelayUrl`): the relays it homes on and a contact's
+* relay before a dial. One spelling, so a contact on this endpoint's relay is reached over the connection already
+* open to it; without the dot, so Safari can open it (a Desktop's record names its relay with the dot).
+*/
+var BROWSER_SPELLING = "plain";
+/**
 * Why a relay URL cannot be used, or null. TLS, except on this machine (a local `iroh-relay --dev`): a page
 * may not open plain WebSockets elsewhere, and the relay's operator would see traffic metadata in the clear.
 */
@@ -23310,7 +24990,7 @@ var IrohWebChannel = class {
 async function createIrohWebEndpoint(seedB64, options = {}) {
 	const seed = fromBase64Url(seedB64);
 	if (seed.length !== 32) throw new Error("Invalid transport seed");
-	const relays = [...options.relays?.length ? options.relays : DEFAULT_IROH_RELAYS];
+	const relays = [...new Set((options.relays?.length ? options.relays : DEFAULT_IROH_RELAYS).map((relay) => irohRelayUrl(relay, BROWSER_SPELLING)))];
 	const node = await (await (options.load ?? loadIrohWasm)()).IrohNode.start(seed, relays, options.onlineMs ?? 1e4);
 	const channels = /* @__PURE__ */ new Set();
 	let stopped = false;
@@ -23340,7 +25020,7 @@ async function createIrohWebEndpoint(seedB64, options = {}) {
 		},
 		async connect(descriptor) {
 			if (stopped) throw new Error("Iroh endpoint is stopped");
-			const conn = await node.connect(descriptor, options.connectMs ?? 2e4);
+			const conn = await node.connect(irohDescriptor(descriptor, BROWSER_SPELLING), options.connectMs ?? 2e4);
 			if (stopped) {
 				conn.close();
 				throw new Error("Iroh endpoint is stopped");
@@ -23448,6 +25128,8 @@ var SPARE_INVITE_WARM_AFTER_TAKE_MS = 3e4;
 */
 var STARTUP_QUIET_MS = 15e3;
 var SPARE_INVITE_MAX_AGE_MS = 9e5;
+/** How far before this clock a warm packet is dated (`warmKey`): further than a contact's clock is ever behind. */
+var WARM_DATED_BACK_MS = 864e5;
 /** How long a removal waits for a wallet's rail to claim what was already paid to it (tests shorten it). */
 var removalTiming = { claimMs: 3e4 };
 /** Why a removal needs the person's confirmation: what it holds, what it still waits for, and what confirming means. */
@@ -23520,12 +25202,34 @@ var GhostlyNode = class GhostlyNode {
 	relays;
 	/** Other profiles of this device, looked at for new messages (WISP 04 § Checking other profiles). */
 	profilePeek;
+	/** Whether this device's WebRTC attempts say direct connections are blocked on its network (`directPath.ts`). */
+	directPath = new DirectPathWatch(() => {
+		if (!this.shuttingDown) this.emitState();
+	});
+	/** Whether this device's clock seems to be off, from what the relays' answers and several contacts' packets say (`clockWatch.ts`). */
+	clock = new ClockWatch(() => {
+		if (!this.shuttingDown) this.emitState();
+	});
+	clockOff;
+	/**
+	* Edges of groups whose WebRTC did not connect in this run of the app (`edgeWithoutRtc`): they go on as an app with
+	* no WebRTC does, over a native transport. Not kept: the next start tries WebRTC first again.
+	*/
+	edgeRtcOff = /* @__PURE__ */ new Set();
 	pollIntervals;
 	localFetch;
 	links = /* @__PURE__ */ new Map();
 	services = [];
 	activeLinkId = null;
-	nativeQueue = Promise.resolve();
+	/**
+	* Native listeners start one at a time per transport (`ensureNativeEndpoints`): their slots are counted per transport.
+	* Not one queue for all: a transport slow to start held every other chat's listeners of every kind behind it.
+	*/
+	nativeQueues = /* @__PURE__ */ new Map();
+	/** Every listener start asked for so far has ended. */
+	get nativeQueue() {
+		return Promise.all(this.nativeQueues.values()).then(() => {});
+	}
 	shuttingDown = false;
 	/** `start` has put the kept transfers back (EngineState.transfersRestored). */
 	transfersRestored = false;
@@ -23551,11 +25255,26 @@ var GhostlyNode = class GhostlyNode {
 	cueFeedback({ cue, key }, linkId) {
 		this.feedback("cue", cue + ":" + key, linkId, false, cue);
 	}
-	/** The newest time stored in each chat while this engine runs: a message landing well behind it is a catch-up. */
+	/** The newest time written in each chat while this engine runs: a message written well before it is a catch-up. */
 	newestAt = /* @__PURE__ */ new Map();
-	/** Only a new message at the end of its chat, or mine going out, says anything (engine/attention.ts). */
+	/** The last place given in each chat while this engine runs (`arrivalKey`). */
+	placedAt = /* @__PURE__ */ new Map();
+	/**
+	* Each 1:1 chat's contact: how far the time its latest live messages said was from when they came (`CLOCK_SAMPLES`
+	* of them). What tells a contact's clock that is behind from a message that is late (`writtenAt`).
+	*/
+	clockLeads = /* @__PURE__ */ new Map();
+	/** A contact's row came on the live session of a 1:1 chat: what it says of the contact's clock is kept. */
+	clockSample(message) {
+		if (message.sender !== "peer" || message.sentAt === void 0 || message.event || message.via !== "datalink" || message.linkId.startsWith("group:")) return;
+		this.clockLeads.set(message.linkId, [...this.clockLeads.get(message.linkId) ?? [], message.sentAt - message.timestamp].slice(-5));
+	}
+	/** Only a new message, or mine going out, says anything (engine/attention.ts): judged by when it was written. */
 	messageFeedback(type, message, newest = this.newestAt.get(message.linkId)) {
-		const attention = messageAttention(type, message, {
+		const attention = messageAttention(type, {
+			...message,
+			timestamp: writtenAt(message, this.clockLeads.get(message.linkId))
+		}, {
 			startedAt: this.feedbackStartedAt,
 			newest,
 			now: Date.now()
@@ -23606,6 +25325,11 @@ var GhostlyNode = class GhostlyNode {
 		deleted: (linkId, messageId) => !!this.links.get(linkId)?.stored.deletedIds?.includes(messageId),
 		messageExists: (linkId, messageId) => db.hasMessage(linkId, messageId),
 		storeMessage: (message) => this.storeMessage(message),
+		place: (linkId) => {
+			const place = arrivalKey(Date.now(), this.placedAt.get(linkId));
+			this.placedAt.set(linkId, place);
+			return place;
+		},
 		transfers: this.transfers,
 		changed: (delayMs) => this.emitState(delayMs),
 		flush: () => this.flushState(),
@@ -23772,7 +25496,8 @@ var GhostlyNode = class GhostlyNode {
 			paymentId: melt.paymentId,
 			mint: melt.mint
 		}),
-		onTestMintNeeded: async (mint) => void await this.walletAddMint({ url: mint })
+		onTestMintNeeded: async (mint) => void await this.walletAddMint({ url: mint }),
+		onSwapSettled: (swap, done) => this.desk.onSwapSettled(swap, done).then(() => swap.payment?.direction === "out" ? this.reviewTakenBack(swap.payment.id) : void 0)
 	}, () => this.settings.mints);
 	registry;
 	providers() {
@@ -23827,7 +25552,7 @@ var GhostlyNode = class GhostlyNode {
 			const stored = this.links.get(linkId)?.stored;
 			return stored?.group && !stored.groupEntry ? stored.group : parsePayLink(linkId)?.groupId;
 		},
-		groupLinks: (groupId) => this.groups.isCommunityGroup(groupId) ? [groupLinkId(groupId)] : [...this.groupEdges(groupId).values()],
+		groupLinks: (groupId) => this.groups.isCommunityGroup(groupId) ? [groupLinkId(groupId)] : [...this.memberEdges(groupId).values()],
 		storeMessage: (message) => this.storeMessage(message),
 		heldPaymentMethods: (linkId) => {
 			const live = this.links.get(linkId);
@@ -24253,11 +25978,14 @@ var GhostlyNode = class GhostlyNode {
 	/** Private groups (WISP 900): sessions, admission on contact chats, and the pairwise edges that carry them. */
 	groups = new Groups({
 		sendOnLink: (linkId, frame) => {
-			const link = this.links.get(linkId)?.link;
-			if (!link) throw new Error("You are offline");
-			link.sendGroupFrame(frame);
+			const live = this.links.get(linkId);
+			if (!live?.link) throw new Error("You are offline");
+			const { group, groupPeer, groupEntry } = live.stored;
+			if (group && groupPeer && !groupEntry && !this.groups.edgeAllows(group, groupPeer, frame)) return;
+			live.link.sendGroupFrame(frame);
 		},
 		linkReady: (linkId, version = 1) => !!this.links.get(linkId)?.link?.supportsGroupVersion(version),
+		linkOpen: (linkId) => !!this.links.get(linkId)?.link?.isDataLinkOpen,
 		myNick: () => this.sharedNick,
 		staysOnline: () => this.options.staysOnline ?? (this.options.platform === "desktop" && typeof RTCPeerConnection !== "undefined"),
 		peerRoom: (groupId) => {
@@ -24289,7 +26017,7 @@ var GhostlyNode = class GhostlyNode {
 		},
 		linkBack: (linkId) => {
 			const live = this.links.get(linkId);
-			return !!live?.lastSyncAt && !!live.presence?.online && live.presence.lastPacketAt > live.lastSyncAt;
+			return !!live?.lastSyncAt && !!live.presence?.online && presenceSeenAt(live.presence) > live.lastSyncAt;
 		},
 		publish: (identity, records, background) => this.groupTransport.publish(identity, records, { background }),
 		resolve: async (pubKeyZ32, background, door) => (await this.groupTransport.resolve(pubKeyZ32, {
@@ -24376,7 +26104,7 @@ var GhostlyNode = class GhostlyNode {
 	}
 	/** The link payments with `linkId` go over: a chat's or an edge's, or a community member's through the group. */
 	paymentLink(linkId) {
-		return this.links.get(linkId)?.link ?? this.communityPay.link(linkId);
+		return this.outsideEdge(linkId) ? null : this.links.get(linkId)?.link ?? this.communityPay.link(linkId);
 	}
 	/**
 	* Payments in groups (WISP 9xx § Payments): the money goes over the edge to one member through the desk, like a
@@ -24395,7 +26123,7 @@ var GhostlyNode = class GhostlyNode {
 				member: stored.groupPeer
 			} : void 0;
 		},
-		edges: (groupId) => this.groups.isCommunityGroup(groupId) ? /* @__PURE__ */ new Map([["*", groupLinkId(groupId)]]) : this.groupEdges(groupId),
+		edges: (groupId) => this.groups.isCommunityGroup(groupId) ? /* @__PURE__ */ new Map([["*", groupLinkId(groupId)]]) : this.memberEdges(groupId),
 		membership: (groupId) => this.membership(groupId),
 		send: (linkId, frame) => {
 			const pay = parsePayLink(linkId);
@@ -24409,17 +26137,56 @@ var GhostlyNode = class GhostlyNode {
 		},
 		messages: (groupId) => db.getMessages(`group:${groupId}`),
 		putMessage: async (message) => {
-			await db.putMessage(message);
+			const kept = await db.getMessage(message.linkId, message.id);
+			await db.putMessage(kept ? {
+				...message,
+				timestamp: kept.timestamp,
+				...kept.sentAt !== void 0 && { sentAt: kept.sentAt }
+			} : this.placed(message));
 			await this.messagesChanged(message.linkId, [message.id]);
 			this.emitState();
 		}
 	});
-	/** Member key → edge link id, for the edges of a group that exist (open or not). */
+	/**
+	* Member key → edge link id, for the edges of a group that exist (open or not), whoever is at the other end: an edge
+	* outlives its member's place in the roster for a moment, or for as long as it is kept to tell it (`StoredGroup.farewells`).
+	* For the group engine alone, which opens and closes them. Whatever is said to the group goes over `memberEdges`.
+	*/
 	groupEdges(groupId) {
 		const edges = /* @__PURE__ */ new Map();
 		for (const live of this.links.values()) if (live.stored.group === groupId && live.stored.groupPeer && !live.stored.groupEntry) edges.set(live.stored.groupPeer, live.stored.id);
 		return edges;
 	}
+	/** The edges of a private group to its members as the roster has them now: the only ones the group's traffic goes over. */
+	memberEdges(groupId) {
+		const edges = this.groupEdges(groupId);
+		for (const key of [...edges.keys()]) if (!this.groups.inRoster(groupId, key)) edges.delete(key);
+		return edges;
+	}
+	/** An edge of a private group to someone its roster no longer has: it says no name and no picture of mine. */
+	quietEdge(stored) {
+		return !!stored && this.meshEdge(stored) && this.groups.outsider(stored.group, stored.groupPeer);
+	}
+	/** Edges that said no name while their other end was out of the roster: the name is said again once it is back in. */
+	quietEdges = /* @__PURE__ */ new Set();
+	/** A group's roster changed: an edge kept to someone now out of it (closed, waiting for them) stops carrying my name. */
+	quietOutsideEdges(groupId) {
+		for (const live of this.links.values()) {
+			if (live.stored.group !== groupId || !live.link || !this.meshEdge(live.stored)) continue;
+			const id = live.stored.id;
+			if (this.quietEdge(live.stored)) {
+				if (!this.quietEdges.has(id) && !live.link.isDataLinkOpen) {
+					this.quietEdges.add(id);
+					live.link.setNick(void 0);
+				}
+			} else if (this.quietEdges.delete(id)) live.link.setNick(this.sharedNick);
+		}
+	}
+	/** An edge of a private group whose other end is not in its roster: nothing of the group goes over it but what the group engine says. */
+	outsideEdge(linkId) {
+		const stored = this.links.get(linkId)?.stored;
+		return !!stored && this.meshEdge(stored) && !this.groups.inRoster(stored.group, stored.groupPeer);
+	}
 	constructor(events, options = {}) {
 		this.events = events;
 		this.options = options;
@@ -24436,6 +26203,7 @@ var GhostlyNode = class GhostlyNode {
 		this.localFetch = options.localFetch ?? webLocalFetch;
 		this.hold.host.transport = this.transport;
 		this.transport.subscribe?.(() => this.emitState());
+		this.clockOff = this.transport.onServerTime?.((time) => this.clock.server(time.source, time.date, time.sent, time.received));
 	}
 	/** The Desktop reaches the DHT itself: the relays in Settings are written to, and read from only when the person chose so. */
 	configureDirect() {
@@ -24519,6 +26287,10 @@ var GhostlyNode = class GhostlyNode {
 			networks[network] = {
 				mints: this.withWaits(view.mints, awaiting.mints),
 				balance: view.balance,
+				setAside: view.setAside,
+				openSwaps: view.openSwaps,
+				swapsAmount: view.swapsAmount,
+				unconfirmed: view.unconfirmed,
 				history,
 				feesPaid: history.reduce((sum, tx) => sum + tx.fee, 0),
 				ark: this.arkWallets[network].view,
@@ -24659,6 +26431,7 @@ var GhostlyNode = class GhostlyNode {
 		});
 		const history = /* @__PURE__ */ new Map();
 		for (const stored of await db.getLinks()) {
+			if (!stored.group) await this.settleHistory(stored.id);
 			const messages = stored.group ? [] : await db.getMessages(stored.id);
 			const storedFiles = stored.group ? [] : await fileStore.listForLink(stored.id);
 			const waiting = new Set(messages.flatMap((m) => m.sender === "me" && m.delivery === "waiting" && m.file ? [m.file.id] : []));
@@ -24671,11 +26444,13 @@ var GhostlyNode = class GhostlyNode {
 			const files = linkFilesFrom(stored.id, storedFiles, messages);
 			this.links.set(stored.id, newLiveLink(stored, messages[messages.length - 1]?.timestamp ?? 0, files));
 			history.set(stored.id, messages);
+			for (const message of messages.slice(-20)) this.clockSample(message);
 			const note = latestReaction(messages);
 			if (note) this.reactionNotes.set(stored.id, note);
 			if (stored.profile && !stored.group) await this.outboxFor(stored.id).recover();
 		}
 		this.transfersRestored = true;
+		for (const group of await db.getGroups()) await this.settleHistory(`group:${group.id}`);
 		await this.groups.load();
 		for (const group of this.groups.views()) {
 			const note = latestReaction(await db.getMessages(`group:${group.id}`));
@@ -24738,6 +26513,9 @@ var GhostlyNode = class GhostlyNode {
 	async shutdown() {
 		this.shuttingDown = true;
 		this.depart();
+		this.directPath.close();
+		this.clock.close();
+		this.clockOff?.();
 		if (this.relayRetry) clearTimeout(this.relayRetry);
 		if (this.activeSlotRetry) clearTimeout(this.activeSlotRetry);
 		for (const timer of this.resumeTimers.values()) clearTimeout(timer);
@@ -24806,6 +26584,8 @@ var GhostlyNode = class GhostlyNode {
 				...this.transport.configure && { direct: true },
 				...this.transport.discovery && { discovery: this.transport.discovery() },
 				...typeof RTCPeerConnection === "undefined" && { webrtc: false },
+				...this.directPath.blocked && { directBlocked: true },
+				...this.clock.offset !== null && { clockOffMs: this.clock.offset },
 				...typeof RTCPeerConnection === "undefined" && !Object.keys(this.nativeFactories).length && { groupLinks: false }
 			},
 			links: [...this.links.values()].filter((live) => !live.stored.group).map((live) => this.viewOf(live)).sort((a, b) => b.createdAt - a.createdAt),
@@ -24886,6 +26666,22 @@ var GhostlyNode = class GhostlyNode {
 			before: from
 		});
 	}
+	async statusCardIndex() {
+		const rows = [];
+		for (const m of await db.getCardMessages()) {
+			if (m.card?.kind !== "task" && m.card?.kind !== "routine") continue;
+			rows.push({
+				linkId: m.linkId,
+				id: m.id,
+				card: m.card,
+				sender: m.sender,
+				...m.member && { member: m.member },
+				timestamp: m.timestamp,
+				...m.edit && { editedAt: m.edit.at }
+			});
+		}
+		return rows;
+	}
 	async createLink() {
 		const { mine, inviteCode } = this.takeInvite();
 		return {
@@ -24913,6 +26709,16 @@ var GhostlyNode = class GhostlyNode {
 			inviteCode: spare.inviteCode
 		};
 	}
+	/**
+	* Warms a key with an empty packet (`emptyLinkRecords`), dated `WARM_DATED_BACK_MS` before this clock. One of the two
+	* keys an invite warms is the contact's: its own first packet has to be the later one, or the relays and the DHT keep
+	* this empty one in its place. Dated by this clock, it was later than the first packets of every contact whose clock
+	* runs behind this one: a joiner two minutes behind stayed unseen for two minutes, one an hour behind for an hour.
+	*/
+	warmKey(identity) {
+		const records = emptyLinkRecords();
+		(this.transport.publishPayload ? this.transport.publishPayload(identity.pubKeyZ32, createRelayPayload(identity, records, BigInt(Date.now() - WARM_DATED_BACK_MS) * 1000n)) : this.transport.publish(identity, records)).catch(() => {});
+	}
 	makeSpare() {
 		const { mine, invite, inviteCode } = createChatInvite();
 		return {
@@ -24938,7 +26744,7 @@ var GhostlyNode = class GhostlyNode {
 		spare.warmedAt ??= Date.now();
 		for (const identity of [identityFromSeedB64(spare.mine.seedB64), spare.inviteKey]) {
 			this.warmedKeys.set(identity.pubKeyZ32, Date.now());
-			this.transport.publish(identity, emptyLinkRecords()).catch(() => {});
+			this.warmKey(identity);
 		}
 		this.spareTimer = setTimeout(() => {
 			this.spareTimer = null;
@@ -25241,6 +27047,7 @@ var GhostlyNode = class GhostlyNode {
 	* (a group on hubs dropped it) and is no longer in the group, or a group I left or forgot, replaces it.
 	*/
 	groupMembersChanged(groupId) {
+		this.quietOutsideEdges(groupId);
 		const holders = this.settings.wakeHeldBy?.[groupId];
 		if (!holders?.length) return;
 		const members = this.membership(groupId)?.members;
@@ -25255,6 +27062,7 @@ var GhostlyNode = class GhostlyNode {
 	groupHistoryGone(groupId) {
 		const linkId = `group:${groupId}`;
 		this.newestAt.delete(linkId);
+		this.placedAt.delete(linkId);
 		this.reactionNotes.delete(linkId);
 		this.events.onMessages(linkId, []);
 	}
@@ -25295,7 +27103,7 @@ var GhostlyNode = class GhostlyNode {
 	async shareGroupWake(linkId) {
 		const live = this.links.get(linkId);
 		const own = this.settings.wake;
-		if (!live?.link?.groupsSupport || !this.meshEdge(live.stored)) return;
+		if (!live?.link?.groupsSupport || !this.meshEdge(live.stored) || this.outsideEdge(linkId)) return;
 		if (this.settings.wakeMutedGroups?.includes(live.stored.group)) {
 			this.sendGroupWake(live, null);
 			return;
@@ -25319,7 +27127,7 @@ var GhostlyNode = class GhostlyNode {
 	/** A `group-wake` frame on an edge: the member it is pinned to shares how to wake it, or says to forget it. */
 	receiveGroupWake(linkId, frame) {
 		const live = this.links.get(linkId);
-		if (!live || !this.meshEdge(live.stored)) return;
+		if (!live || !this.meshEdge(live.stored) || this.outsideEdge(linkId)) return;
 		let window = this.groupWakeReceived.get(linkId);
 		if (!window) this.groupWakeReceived.set(linkId, window = new RateWindow(6, 6e4));
 		if (!window.take()) return;
@@ -25338,7 +27146,7 @@ var GhostlyNode = class GhostlyNode {
 	*/
 	wakeMentioned(groupId, text, mentions) {
 		if (!mentions.length || !this.settings.online || this.groups.isCommunityGroup(groupId)) return;
-		const edges = this.groupEdges(groupId);
+		const edges = this.memberEdges(groupId);
 		const wakes = groupWakes({
 			group: groupId,
 			mentions,
@@ -25474,7 +27282,10 @@ var GhostlyNode = class GhostlyNode {
 	* (`network`): relays left alone for failing on the old network are asked again at once.
 	*/
 	wake(params = {}) {
-		if (params.network) this.transport.networkChanged?.();
+		if (params.network) {
+			this.transport.networkChanged?.();
+			this.directPath.reset();
+		}
 		for (const live of this.links.values()) live.link?.wake();
 		this.hold.wake();
 		for (const network of WALLET_NETWORKS) {
@@ -25519,7 +27330,7 @@ var GhostlyNode = class GhostlyNode {
 		};
 		if (!live?.link) return { error: "You are offline" };
 		if (!trimmed) return { error: null };
-		const timestamp = params.timestamp ?? Date.now();
+		const timestamp = params.timestamp ?? arrivalKey(Date.now(), this.placedAt.get(linkId));
 		if (live.stored.profile) live.link.setTyping(false);
 		if (live.stored.profile) {
 			const found = params.replyTo === void 0 ? void 0 : await this.replyFor(linkId, params.replyTo);
@@ -25590,6 +27401,7 @@ var GhostlyNode = class GhostlyNode {
 	async sendChatText(live, trimmed, timestamp, preview, reply, forwarded, card) {
 		const { link } = live, linkId = live.stored.id;
 		if (!link) return { error: "You are offline" };
+		this.chatInUse(live);
 		const bytes = new TextEncoder().encode(trimmed).length;
 		if (bytes > LIMITS.maxChatMessageBytes) return {
 			error: `Message exceeds ${LIMITS.maxChatMessageBytes} UTF-8 bytes.`,
@@ -25841,7 +27653,7 @@ var GhostlyNode = class GhostlyNode {
 			if (!takesPeerEdit(current, edit.m) || (current.edit?.seq ?? 0) >= edit.e) return null;
 			const next = withEdit(current, {
 				seq: edit.e,
-				at: receivedTimestamp(edit.ts),
+				at: heardTime(edit.ts),
 				text: edit.m,
 				preview: edit.pv,
 				card: edit.sc
@@ -25983,6 +27795,7 @@ var GhostlyNode = class GhostlyNode {
 	outboxFor(linkId) {
 		let outbox = this.outboxes.get(linkId);
 		if (!outbox) {
+			const chat = this.links.get(linkId)?.stored;
 			outbox = new Outbox({
 				read: () => db.getMessages(linkId),
 				update: async (id, delivery, error, extra) => {
@@ -26012,10 +27825,12 @@ var GhostlyNode = class GhostlyNode {
 			}, { resender: {
 				ready: (message) => {
 					const live = this.links.get(linkId), link = live?.link;
+					if (message.file && !message.wireId) return !!link?.isDataLinkOpen && link.textDelivery === "stream";
 					if (message.via === "pkarr" && !GhostlyNode.dhtByChoice(live) && link?.textDelivery !== "stream") return false;
 					return !!link?.canSendText && !!message.wireId && !link.validateText(message.text, message.timestamp, message.wireId, GhostlyNode.wireReply(message));
 				},
 				requeueExpired: () => !GhostlyNode.dhtByChoice(this.links.get(linkId)),
+				...!!chat?.profile && !chat.group && { sendFile: (message) => this.sendWaitingFile(linkId, message) },
 				via: (message) => {
 					const delivery = this.links.get(linkId)?.link?.textDelivery;
 					return delivery === "dht" ? "pkarr" : delivery === "stream" ? "datalink" : message.via;
@@ -26390,12 +28205,19 @@ var GhostlyNode = class GhostlyNode {
 	*/
 	transferFile(live, file, wireId, timestamp, fail, reply, forwarded) {
 		const { link } = live;
-		if (!link) return fail("You are offline");
+		if (!link) {
+			fail("You are offline");
+			return Promise.resolve();
+		}
 		this.transfers.set(file.id, {
 			state: "transferring",
 			transferred: 0,
 			size: file.size
 		});
+		let said = () => {};
+		const offered = new Promise((resolve) => {
+			said = resolve;
+		});
 		(async () => {
 			if (!reply || !forwarded) {
 				const message = (await db.getMessages(live.stored.id)).find((m) => m.id === `me_${timestamp}`);
@@ -26427,6 +28249,7 @@ var GhostlyNode = class GhostlyNode {
 				size: file.size
 			});
 			const source = streamStored(stored);
+			said();
 			await link.sendFile({
 				id: wireId,
 				name: file.name,
@@ -26439,7 +28262,8 @@ var GhostlyNode = class GhostlyNode {
 				...reply && { reply },
 				...forwarded && { forwarded }
 			}, source);
-		})().catch((error) => fail(error instanceof Error ? error.message : String(error)));
+		})().catch((error) => fail(error instanceof Error ? error.message : String(error))).finally(said);
+		return offered;
 	}
 	fileAction({ linkId, fileId, action }) {
 		const live = this.links.get(linkId);
@@ -26468,13 +28292,39 @@ var GhostlyNode = class GhostlyNode {
 		return link.supportsLargeFiles;
 	}
 	/**
-	* The chat is live: what waited for it goes now, in the order it was written. A file for an app that turns
-	* out not to take files fails with that reason instead of waiting forever (WISP 03).
+	* A file that waited for the chat to be live goes: said on the open session (see `transferFile`), and this returns
+	* then, so the chat's outbox sends it in its place among the texts that waited (WISP 400, requirement 10). A file
+	* for an app that turns out not to take files fails with that reason instead of waiting forever (WISP 03).
+	*/
+	async sendWaitingFile(linkId, message) {
+		const live = this.links.get(linkId), file = message.file;
+		if (!live?.link?.isDataLinkOpen || !file) return;
+		if (!GhostlyNode.takesFiles(live.link)) await GhostlyNode.largeFilesAgreed(live.link);
+		if (!live.link.isDataLinkOpen) return;
+		if (!GhostlyNode.takesFiles(live.link)) await db.updateDelivery(linkId, message.id, "failed", "Your contact's app cannot receive files.");
+		else {
+			await db.putMessage(sentNow(message));
+			await this.transferFile(live, file, file.id.slice(`${linkId}-out-`.length), message.timestamp, (error) => {
+				this.transfers.set(file.id, {
+					state: "failed",
+					transferred: 0,
+					size: file.size,
+					error
+				});
+				this.emitState();
+			}, GhostlyNode.wireReply(message));
+		}
+		await this.messagesChanged(linkId, [message.id]);
+	}
+	/**
+	* The chat is live: what waited for it goes now, in the order it was written. A 1:1 chat's files go with its texts,
+	* through its outbox (`sendWaitingFile`); here its payment requests, and everything of any other chat.
 	*/
 	async sendWaiting(linkId) {
 		const live = this.links.get(linkId);
 		if (!live?.link?.isDataLinkOpen) return;
-		const waiting = (await db.getMessages(linkId)).filter((m) => m.sender === "me" && m.delivery === "waiting" && (m.file || m.paymentId)).sort((a, b) => a.timestamp - b.timestamp);
+		const withTexts = this.outboxFor(linkId).sendsFiles;
+		const waiting = (await db.getMessages(linkId)).filter((m) => m.sender === "me" && m.delivery === "waiting" && (m.file && !withTexts || m.paymentId)).sort((a, b) => a.timestamp - b.timestamp);
 		if (waiting.some((m) => m.file) && !GhostlyNode.takesFiles(live.link)) await GhostlyNode.largeFilesAgreed(live.link);
 		for (const message of waiting) if (message.file) {
 			if (!GhostlyNode.takesFiles(live.link)) {
@@ -26833,7 +28683,9 @@ var GhostlyNode = class GhostlyNode {
 	}
 	async createGroup({ name, profile }) {
 		if (typeof name !== "string" || !name.trim()) throw new Error("Give the group a name");
-		return { groupId: await this.groups.create(name.trim().slice(0, 48), profile === "mesh" ? "mesh" : "community") };
+		const clean = groupName(name);
+		if (!clean) throw new Error(`A group's name is 1 to 64 characters on one line`);
+		return { groupId: await this.groups.create(clean, profile === "mesh" ? "mesh" : "community") };
 	}
 	inviteToGroup({ groupId, linkId }) {
 		if (!this.links.get(linkId)?.stored.profile || this.links.get(linkId)?.stored.group) throw new Error("Invite a paired contact");
@@ -27044,7 +28896,10 @@ var GhostlyNode = class GhostlyNode {
 		if (typeof linkId !== "string" || !linkId) return { error: "No chat to react in" };
 		if (linkId.startsWith("group:")) {
 			const groupId = linkId.slice(6);
-			if (!this.membership(groupId)) return { error: "You are not in this group" };
+			if (!this.membership(groupId)) return {
+				error: this.groups.views().find((g) => g.id === groupId)?.statusReason ?? "You are not in this group",
+				refused: true
+			};
 			const result = await this.reactions.mine(linkId, messageId, emoji);
 			return "error" in result ? result : this.sendGroupReaction(groupId, result.reaction);
 		}
@@ -27131,13 +28986,14 @@ var GhostlyNode = class GhostlyNode {
 			...wireReaction(reaction),
 			...this.groups.signReaction(groupId, wireReaction(reaction))
 		};
-		for (const edge of this.groupEdges(groupId).values()) try {
+		for (const edge of this.memberEdges(groupId).values()) try {
 			this.links.get(edge)?.link?.sendGroupFrame(frame);
 		} catch {}
 		return { error: null };
 	}
 	/** An edge of a private group opened: the member hears my latest reactions again, in case it missed them. */
 	async resendGroupReactions(groupId, linkId) {
+		if (this.outsideEdge(linkId)) return;
 		const mine = groupReactionsToResend(await db.getMessages(`group:${groupId}`), REACTION_LIMITS.pending);
 		for (const reaction of mine) try {
 			this.links.get(linkId)?.link?.sendGroupFrame({
@@ -27197,7 +29053,7 @@ var GhostlyNode = class GhostlyNode {
 				k: frame.k,
 				sig: frame.sig
 			});
-			for (const member of this.groupEdges(groupId).keys()) this.sendGroupPinFrame(groupId, member);
+			for (const member of this.memberEdges(groupId).keys()) this.sendGroupPinFrame(groupId, member);
 			return { error: null };
 		}
 		const live = this.links.get(linkId);
@@ -27282,11 +29138,11 @@ var GhostlyNode = class GhostlyNode {
 				sig: via.frame.sig
 			}
 		}) || !via) return;
-		for (const key of this.groupEdges(groupId).keys()) if (key !== via.from && key !== member) this.sendGroupPinFrame(groupId, key);
+		for (const key of this.memberEdges(groupId).keys()) if (key !== via.from && key !== member) this.sendGroupPinFrame(groupId, key);
 	}
 	/** A private group's pin, as its pinner signed it, over the edge to `member`; nothing when it is down (said when it opens). */
 	sendGroupPinFrame(groupId, member) {
-		const pin = this.groups.pinOf(groupId), edge = this.groupEdges(groupId).get(member);
+		const pin = this.groups.pinOf(groupId), edge = this.memberEdges(groupId).get(member);
 		if (!pin?.k || !pin.sig || !edge || this.groups.isCommunityGroup(groupId) || !pinNumberHolds(pin.n)) return;
 		const frame = {
 			t: "group-pin",
@@ -27497,6 +29353,13 @@ var GhostlyNode = class GhostlyNode {
 		if (!WALLET_TYPES.includes(type)) throw new Error("Unknown kind of wallet");
 		if (network !== "mainnet" && network !== "testnet") throw new Error("Choose Mainnet or Testnet");
 		await this.lightnings[network].start();
+		if (type === "cashu") {
+			let timer;
+			await Promise.race([this.wallet.settleSwaps(this.networkMints(network)).catch(() => {}), new Promise((resolve) => {
+				timer = setTimeout(resolve, removalTiming.claimMs);
+			})]);
+			clearTimeout(timer);
+		}
 		await this.refreshWallet();
 		const card = type === "lightning" ? asked ?? this.lightnings[network].receivingId : void 0;
 		const lightningName = card !== void 0 ? this.walletView.networks?.[network].lightnings?.find((c) => c.card === card)?.name : void 0;
@@ -27515,7 +29378,7 @@ var GhostlyNode = class GhostlyNode {
 		try {
 			if (type === "cashu") {
 				const mints = this.networkMints(network);
-				await this.wallet.forget(mints);
+				await this.wallet.forget(mints, acceptLoss === true);
 				await this.updateSettings({ settings: { mints: this.settings.mints.filter((m) => !mints.includes(m)) } });
 			} else if (type === "arkade") await this.arkWallets[network].remove();
 			else if (type === "bark") await this.barkWallets[network].remove();
@@ -28195,8 +30058,32 @@ var GhostlyNode = class GhostlyNode {
 	payRequest(params) {
 		return this.desk.payRequest(params);
 	}
-	reclaimPayment({ paymentId }) {
-		return this.desk.reclaim(paymentId);
+	async reclaimPayment({ paymentId }) {
+		await this.desk.reclaim(paymentId);
+		await this.reviewTakenBack(paymentId);
+	}
+	/**
+	* A reviewed payment whose ecash this wallet took back: its review ends failed, at once. The mint reads that ecash
+	* spent (this wallet redeemed it), which the review would otherwise take for the contact being paid, and a request
+	* whose review reads paid can never be reviewed again. Only when the ecash is back for certain (`reclaimed`).
+	*/
+	async reviewTakenBack(id) {
+		if (this.desk.payment(id)?.state !== "reclaimed") return;
+		const intent = await intentRepository.get(id);
+		if (!intent || intent.review.method !== "cashu" || ![
+			"submitted",
+			"unknown",
+			"settled"
+		].includes(intent.review.state)) return;
+		await intentRepository.put({
+			...intent,
+			review: {
+				...intent.review,
+				state: "failed",
+				error: engineText("paymentTakenBack")
+			}
+		});
+		this.emitState();
 	}
 	addService({ name, target }) {
 		const cleanName = name.trim().slice(0, 48);
@@ -28332,9 +30219,11 @@ var GhostlyNode = class GhostlyNode {
 				this.publicActivity.clear();
 			}
 		}
-		if (settings.avatar !== void 0 || settings.shareProfile !== void 0) for (const live of this.links.values()) live.link?.setAvatar(this.sharedAvatar);
+		if (settings.avatar !== void 0 || settings.shareProfile !== void 0) {
+			for (const live of this.links.values()) if (!this.quietEdge(live.stored)) live.link?.setAvatar(this.sharedAvatar);
+		}
 		if (settings.nick !== void 0 || settings.shareProfile !== void 0) {
-			for (const live of this.links.values()) live.link?.setNick(this.sharedNick);
+			for (const live of this.links.values()) if (!this.quietEdge(live.stored)) live.link?.setNick(this.sharedNick);
 			this.capsChanged();
 		}
 		if (settings.hyperdhtRelay !== void 0) {
@@ -28422,7 +30311,7 @@ var GhostlyNode = class GhostlyNode {
 			const identity = identityFromSeedB64(invite.seedB64);
 			if (Date.now() - (this.warmedKeys.get(identity.pubKeyZ32) ?? 0) < SPARE_INVITE_MAX_AGE_MS) return;
 			this.warmedKeys.set(identity.pubKeyZ32, Date.now());
-			this.transport.publish(identity, emptyLinkRecords()).catch(() => {});
+			this.warmKey(identity);
 		} catch {}
 	}
 	/** What this peer advertises. Chat, voice and video are what Ghostly always offered. */
@@ -28460,7 +30349,9 @@ var GhostlyNode = class GhostlyNode {
 		const live = this.links.get(linkId);
 		if (!live?.stored.group) return;
 		this.links.delete(linkId);
+		this.edgeRtcOff.delete(linkId);
 		this.groupWakeReceived.delete(linkId);
+		this.quietEdges.delete(linkId);
 		this.groupNativeWaiting.delete(linkId);
 		this.groupNativeRetryAt = 0;
 		if (live.stored.wakeToken && this.meshEdge(live.stored)) {
@@ -28582,11 +30473,13 @@ var GhostlyNode = class GhostlyNode {
 		const { stored } = live;
 		const group = stored.group, peer = stored.groupPeer, entry = !!stored.groupEntry;
 		const role = stored.groupEntry ?? "edge";
+		const member = () => entry || this.groups.isCommunityGroup(group) || this.groups.inRoster(group, peer);
 		let seen = false;
 		const native = this.keepsGroupNative(stored);
 		const resumeOn = native ? TRANSPORTS.find((t) => t !== "webrtc/1" && t in this.nativeFactories && !!stored.peerTransports?.includes(t)) : "webrtc/1";
 		live.pairing = { status: "connecting" };
 		live.link = new GhostLink({
+			ownRecords: true,
 			paymentMethods: entry ? {
 				cashu: false,
 				lightning: false,
@@ -28601,7 +30494,7 @@ var GhostlyNode = class GhostlyNode {
 			usdtPaymentsSupport: !entry,
 			barkPaymentsSupport: !entry,
 			params: stored,
-			rtcAvailable: typeof RTCPeerConnection !== "undefined",
+			rtcAvailable: typeof RTCPeerConnection !== "undefined" && !this.edgeRtcOff.has(linkId),
 			resume: !entry && stored.edgeLive ? resumeOn : void 0,
 			native: {
 				peerDescriptors: stored.peerDescriptors,
@@ -28624,7 +30517,7 @@ var GhostlyNode = class GhostlyNode {
 				trustOnFirstUse: false
 			},
 			transport: this.groupTransport,
-			nick: this.sharedNick,
+			nick: !entry && this.quietEdge(stored) ? void 0 : this.sharedNick,
 			pollIntervals: entry || this.groups.isCommunityGroup(group) ? this.pollIntervals : meshEdgeIntervals(this.pollIntervals, () => this.groups.meshSize(group)),
 			autoConnect: true,
 			...entry ? {
@@ -28640,12 +30533,13 @@ var GhostlyNode = class GhostlyNode {
 			getHostedHttpService: () => void 0,
 			groupsSupport: true,
 			events: {
-				onGroupFrame: (frame) => entry ? this.groups.handleContactFrame(linkId, frame) : frame.t === "group-pay" ? this.groupPayments.receive(group, peer, frame) : frame.t === "group-wake" ? this.receiveGroupWake(linkId, frame) : this.groups.handleEdgeFrame(group, peer, frame),
+				onGroupFrame: (frame) => entry ? this.groups.handleContactFrame(linkId, frame) : !member() ? this.groups.handleEdgeFrame(group, peer, frame) : frame.t === "group-pay" ? this.groupPayments.receive(group, peer, frame) : frame.t === "group-wake" ? this.receiveGroupWake(linkId, frame) : this.groups.handleEdgeFrame(group, peer, frame),
 				onGroupsSupport: (supported) => {
 					if (supported) traceJoin(group, "link.ready", { role });
 					if (!entry) this.noteEdgeLive(linkId, supported);
 					if (supported) {
 						if (entry) this.groups.entryReady(group, linkId, peer);
+						else if (!member()) this.groups.edgeReady(group, peer, linkId);
 						else {
 							this.groups.edgeReady(group, peer, linkId);
 							this.groupPayments.edgeReady(group, linkId).catch(() => {});
@@ -28670,10 +30564,10 @@ var GhostlyNode = class GhostlyNode {
 					if (this.keepsGroupNative(live.stored)) this.ensureNativeEndpoints(linkId);
 				},
 				...entry ? {} : {
-					onPaymentRequest: (request) => this.desk.onPaymentRequest(linkId, request),
-					onPaymentAsk: (ask) => this.desk.onPaymentAsk(linkId, ask),
-					onPayment: (payment) => this.desk.onPayment(linkId, payment),
-					onPaymentResult: (result) => this.desk.onPaymentResult(linkId, result),
+					onPaymentRequest: (request) => member() ? this.desk.onPaymentRequest(linkId, request) : void 0,
+					onPaymentAsk: (ask) => member() ? this.desk.onPaymentAsk(linkId, ask) : void 0,
+					onPayment: (payment) => member() ? this.desk.onPayment(linkId, payment) : void 0,
+					onPaymentResult: (result) => member() ? this.desk.onPaymentResult(linkId, result) : void 0,
 					onPeerNick: (nick) => this.groups.edgeNick(group, peer, nick ?? void 0)
 				},
 				onPresence: (presence) => {
@@ -28693,10 +30587,15 @@ var GhostlyNode = class GhostlyNode {
 					live.pairing = state;
 					this.emitState();
 				},
+				onDirectEvidence: (evidence) => {
+					this.directPath.note(peer, evidence);
+					if (!entry && evidence !== "open" && evidence !== "closed") this.edgeWithoutRtc(linkId);
+				},
 				onDataLinkState: (state) => {
 					traceJoin(group, `link.${state}`, { role });
 					if (state === "open" || live.dataLink === "open") live.lastSyncAt = Date.now();
-					if (state === "open" && !entry) this.desk.replay(linkId).catch(() => {});
+					if (state === "open" && !entry) this.groups.edgeOpen(group, peer);
+					if (state === "open" && !entry && member()) this.desk.replay(linkId).catch(() => {});
 					live.dataLink = state;
 					if (entry && state !== "open" && live.entryDone) this.closeGroupLink(linkId).catch(() => {});
 					if (state !== "open" && live.pairing?.status !== "error") live.pairing = { status: "connecting" };
@@ -28723,7 +30622,27 @@ var GhostlyNode = class GhostlyNode {
 	*/
 	keepsGroupNative(stored) {
 		if (this.options.webrtcGroupLinks) return false;
-		return typeof RTCPeerConnection === "undefined" || !!stored.peerTransports && !stored.peerTransports.includes("webrtc/1");
+		return typeof RTCPeerConnection === "undefined" || this.edgeRtcOff.has(stored.id) || !!stored.peerTransports && !stored.peerTransports.includes("webrtc/1");
+	}
+	/**
+	* An edge's WebRTC attempt exchanged both descriptions and connected nothing, or found no candidate at all
+	* (`DirectEvidence`): a network that lets no direct connection through (a VPN, a firewall, on either side). WebRTC is
+	* all an edge between two apps that have it runs, and there is no TURN server unless someone set one, so the edge
+	* never went live, and the member stayed unreachable for as long as that network lasted. The edge starts again as on an
+	* app with no WebRTC (WISP 9xx § Transports): it runs its native endpoints and says so in its packet (`_tr`, with no
+	* `webrtc/1`), the member's app starts its own for it as it does for a Linux Desktop, and the two meet over Iroh
+	* through its relay. For this run of the app only.
+	*/
+	async edgeWithoutRtc(linkId) {
+		const live = this.links.get(linkId), link = live?.link;
+		if (!live || !link || !live.stored.group || live.stored.groupEntry || this.shuttingDown || this.options.webrtcGroupLinks) return;
+		if (this.edgeRtcOff.has(linkId) || this.keepsGroupNative(live.stored) || !Object.keys(this.nativeFactories).length) return;
+		this.edgeRtcOff.add(linkId);
+		traceLink(live.myPubKeyZ32, "edge-rtc-off", {});
+		live.link = null;
+		await link.stop(false).catch(() => {});
+		if (this.links.get(linkId) !== live || live.link || this.shuttingDown || this.settings.online === false) return;
+		this.startEdge(linkId);
 	}
 	startLink(linkId, messages) {
 		const live = this.links.get(linkId);
@@ -28731,7 +30650,7 @@ var GhostlyNode = class GhostlyNode {
 		const { stored } = live;
 		if (stored.group) return this.startEdge(linkId);
 		if (stored.profile) live.pairing = { status: "connecting" };
-		const lastSeenTimestamp = messages.reduce((max, m) => m.sender === "peer" && m.via === "pkarr" ? Math.max(max, m.timestamp) : max, 0);
+		const lastSeenTimestamp = messages.reduce((max, m) => m.sender === "peer" && m.via === "pkarr" ? Math.max(max, m.sentAt ?? m.timestamp) : max, 0);
 		const credentials = stored.profile && stored.participationSeed ? {
 			seedB64: stored.participationSeed,
 			peerKey: stored.pairedPeerKey,
@@ -28964,6 +30883,11 @@ var GhostlyNode = class GhostlyNode {
 					live.peerAck = ack;
 					this.emitState();
 				},
+				onDirectEvidence: (evidence) => this.directPath.note(stored.peerPubKeyZ32, evidence),
+				onPeerClock: (packetAt, readBefore, readAt) => {
+					const peer = live.stored.pairedPeerKey;
+					if (peer && !live.stored.group) this.clock.peer(peer, packetAt, readBefore, readAt);
+				},
 				onDataLinkState: (state) => {
 					const was = live.dataLink;
 					live.dataLink = state;
@@ -29023,6 +30947,7 @@ var GhostlyNode = class GhostlyNode {
 						};
 						db.patchLink(linkId, { inviteCode: void 0 });
 					}
+					if (message.via !== "datalink") this.chatInUse(live);
 					return this.storeMessage({
 						linkId,
 						id: `peer_${message.id ?? message.timestamp}`,
@@ -29100,7 +31025,8 @@ var GhostlyNode = class GhostlyNode {
 					};
 				},
 				changed: (record) => this.peerCapsChanged(linkId, record),
-				published: () => live.link?.announceCapsRevision()
+				published: () => live.link?.announceCapsRevision(),
+				refused: (error) => traceLink(live.myPubKeyZ32, "caps-refused", { reason: error.reason })
 			});
 			if (stored.pairedPeerKey && nativeUp) {
 				const late = setTimeout(() => caps.start(), STARTUP_QUIET_MS);
@@ -29191,7 +31117,7 @@ var GhostlyNode = class GhostlyNode {
 	get nativeFactories() {
 		const relay = this.relaysHyperdht ? this.hyperdhtRelay : "";
 		return {
-			...relay ? { "hyperdht/1": async (seedB64) => (await import("./hyperdhtRelay-_rJsllcP.js")).createRelayedHyperEndpoint(seedB64, relay) } : {},
+			...relay ? { "hyperdht/1": async (seedB64) => (await import("./hyperdhtRelay-VM9STKLd.js")).createRelayedHyperEndpoint(seedB64, relay) } : {},
 			...this.options.nativeTransports,
 			...this.options.irohWeb ? { "iroh/1": (seedB64) => createIrohWebEndpoint(seedB64, { relays: this.irohRelays }) } : {}
 		};
@@ -29254,70 +31180,110 @@ var GhostlyNode = class GhostlyNode {
 		}
 		this.emitState();
 	}
-	ensureNativeEndpoints(linkId) {
+	/**
+	* A text going or coming in a 1:1 chat with no live session: the chat is in use, and takes the native listeners it
+	* lacks as the chat on screen would (a bot answering its ninth contact has no chat on screen).
+	*/
+	chatInUse(live) {
+		const link = live.link;
+		if (live.stored.group || !link || link.isDataLinkOpen || !this.keepsNativeEndpoints(live.stored.id, live.stored)) return;
+		if (Object.keys(this.nativeFactories).every((t) => link.availableTransports.includes(t))) return;
+		this.ensureNativeEndpoints(live.stored.id, true);
+	}
+	/**
+	* Whether the chat goes live only over a native transport: this app has no WebRTC, or its contact has none (its record
+	* lists no `webrtc/1`). Not known yet (no record read) counts as only natively, as a chat before its first record must.
+	*/
+	reachedOnlyNatively(live) {
+		const theirs = live.stored.capsState?.peer?.transports ?? live.stored.peerTransports;
+		return typeof RTCPeerConnection === "undefined" || !theirs || !theirs.includes("webrtc/1");
+	}
+	/** `inUse`: a text is going or coming in the chat now, which counts as the chat on screen does for taking a listener. */
+	ensureNativeEndpoints(linkId, inUse = false) {
 		const expected = this.links.get(linkId)?.link;
-		const operation = this.nativeQueue.then(async () => {
+		const starts = Object.entries(this.nativeFactories).map(([transport, factory]) => {
+			const key = transport;
+			const operation = (this.nativeQueues.get(key) ?? Promise.resolve()).then(() => factory ? this.startNativeEndpoint(linkId, expected, key, factory, inUse) : false);
+			this.nativeQueues.set(key, operation.then(() => {}, () => {}));
+			return operation;
+		});
+		return Promise.all(starts).then((full) => {
 			const live = this.links.get(linkId), link = live?.link;
-			if (this.shuttingDown || !live?.stored.profile || live.stored.deliveryMode === "dht" || !link || link !== expected) return;
-			const group = !!live.stored.group;
-			if (group && !this.keepsGroupNative(live.stored)) return;
-			let full = false;
-			for (const [transport, factory] of Object.entries(this.nativeFactories)) {
-				const key = transport;
-				if (!factory || link.availableTransports.includes(key)) continue;
-				live.transportErrors ??= {};
-				try {
-					const owners = [...this.links.values()].filter((other) => other.link?.availableTransports.includes(key));
-					if (group && (owners.length >= NATIVE_SLOTS || owners.filter((other) => other.stored.group).length >= 4)) {
-						full = true;
-						continue;
-					}
-					if (owners.length >= NATIVE_SLOTS) {
-						const victim = owners.filter((other) => other.stored.group && other.link?.canReleaseEndpoint(key)).sort((a, b) => (a.link?.isDataLinkOpen ? 1 : 0) - (b.link?.isDataLinkOpen ? 1 : 0))[0] ?? (this.activeLinkId === linkId ? owners.filter((other) => other !== live && other.stored.id !== this.activeLinkId && other.link?.canReleaseEndpoint(key)).sort((a, b) => a.lastMessageAt - b.lastMessageAt)[0] : void 0);
-						if (!victim) {
-							traceLink(live.myPubKeyZ32, "native-no-slot", {
-								transport: key,
-								active: this.activeLinkId === linkId
-							});
-							if (this.activeLinkId === linkId && !group) this.retryActiveSlot(linkId);
-							throw new Error("All eight native connection slots are in use. Disconnect a native connection in another chat, then reopen this chat or press Reconnect.");
-						}
-						await victim.link.releaseEndpoint(key);
-						victim.transportErrors ??= {};
-						victim.transportErrors[key] = "Listener released for another chat. Open this chat to restore it; your messages and transport identity are saved.";
-						if (victim.stored.group) this.groupNativeWaiting.add(victim.stored.id);
-					}
-					if (this.shuttingDown || live.link !== link) return;
-					const seed = live.stored.transportSeeds?.[key] ?? createIdentity().seedB64;
-					const transportSeeds = {
-						...live.stored.transportSeeds,
-						[key]: seed
-					};
-					await db.patchLink(linkId, { transportSeeds });
-					live.stored = {
-						...live.stored,
-						transportSeeds
+			if (this.shuttingDown || !live || !link || link !== expected) return;
+			if (live.stored.group && this.keepsGroupNative(live.stored)) {
+				if (full.some(Boolean) && !link.availableTransports.some((t) => t !== "webrtc/1")) this.groupNativeWaiting.add(linkId);
+				else this.groupNativeWaiting.delete(linkId);
+			}
+			this.emitState();
+		});
+	}
+	/** One transport's listener for one chat, in that transport's queue. True when a group's link found no slot free. */
+	async startNativeEndpoint(linkId, expected, key, factory, inUse) {
+		const live = this.links.get(linkId), link = live?.link;
+		if (this.shuttingDown || !live?.stored.profile || live.stored.deliveryMode === "dht" || !link || link !== expected) return false;
+		const group = !!live.stored.group;
+		if (group && !this.keepsGroupNative(live.stored)) return false;
+		if (link.availableTransports.includes(key)) return false;
+		live.transportErrors ??= {};
+		try {
+			const owners = [...this.links.values()].filter((other) => other.link?.availableTransports.includes(key));
+			if (group && (owners.length >= NATIVE_SLOTS || owners.filter((other) => other.stored.group).length >= 4)) return true;
+			if (owners.length >= NATIVE_SLOTS) {
+				const now = Date.now();
+				const taking = !group && (this.activeLinkId === linkId || inUse);
+				const victim = owners.filter((other) => other.stored.group && other.link?.canReleaseEndpoint(key)).sort((a, b) => (a.link?.isDataLinkOpen ? 1 : 0) - (b.link?.isDataLinkOpen ? 1 : 0))[0] ?? (taking ? owners.filter((other) => other !== live && other.stored.id !== this.activeLinkId && other.link?.canReleaseEndpoint(key) && now - (other.nativeTakenAt?.[key] ?? 0) >= 12e4).sort((a, b) => a.lastMessageAt - b.lastMessageAt)[0] : void 0);
+				const idle = victim || !taking || !this.reachedOnlyNatively(live) ? void 0 : owners.filter((other) => other !== live && !other.stored.group && other.stored.id !== this.activeLinkId && !this.fileDesk.moving(other.stored.id) && other.link?.canYieldEndpoint(key, 12e4)).sort((a, b) => a.link.lastActivityAt - b.link.lastActivityAt)[0];
+				const idleFor = idle ? now - idle.link.lastActivityAt : 0;
+				if (idle && await idle.link.yieldEndpoint(key, 12e4)) {
+					traceLink(live.myPubKeyZ32, "native-take", {
+						transport: key,
+						idle: idleFor,
+						active: this.activeLinkId === linkId
+					});
+					live.nativeTakenAt = {
+						...live.nativeTakenAt,
+						[key]: Date.now()
 					};
-					const endpoint = await factory(seed);
-					if (this.shuttingDown || live.stored.deliveryMode === "dht" || live.link !== link || !this.links.has(linkId)) {
-						await endpoint.close();
-						return;
-					}
-					link.registerEndpoint(endpoint);
-					delete live.transportErrors[key];
-					this.capsChanged(linkId);
-				} catch (error) {
-					live.transportErrors[key] = error instanceof Error ? error.message : "Native adapter could not start. Reopen this chat to retry.";
+					idle.transportErrors ??= {};
+					idle.transportErrors[key] = "Listener given to a chat in use: this one was quiet. Open this chat to take one back; your messages and transport identity are saved.";
+				} else if (!victim) {
+					traceLink(live.myPubKeyZ32, "native-no-slot", {
+						transport: key,
+						active: this.activeLinkId === linkId
+					});
+					if (this.activeLinkId === linkId && !group) this.retryActiveSlot(linkId);
+					throw new Error("All eight native connection slots are in use. This chat takes one once a chat live over one has been quiet for 2 minutes. Disconnect a native connection in another chat to free one now.");
+				} else {
+					await victim.link.releaseEndpoint(key);
+					victim.transportErrors ??= {};
+					victim.transportErrors[key] = "Listener released for another chat. Open this chat to restore it; your messages and transport identity are saved.";
+					if (victim.stored.group) this.groupNativeWaiting.add(victim.stored.id);
 				}
 			}
-			if (group) {
-				if (full && !link.availableTransports.some((t) => t !== "webrtc/1")) this.groupNativeWaiting.add(linkId);
-				else this.groupNativeWaiting.delete(linkId);
+			if (this.shuttingDown || live.link !== link) return false;
+			const seed = live.stored.transportSeeds?.[key] ?? createIdentity().seedB64;
+			const transportSeeds = {
+				...live.stored.transportSeeds,
+				[key]: seed
+			};
+			live.stored = {
+				...live.stored,
+				transportSeeds
+			};
+			await db.patchLink(linkId, { transportSeeds });
+			const endpoint = await factory(seed);
+			if (this.shuttingDown || live.stored.deliveryMode === "dht" || live.link !== link || !this.links.has(linkId)) {
+				await endpoint.close();
+				return false;
 			}
+			link.registerEndpoint(endpoint);
+			delete live.transportErrors[key];
+			this.capsChanged(linkId);
 			this.emitState();
-		});
-		this.nativeQueue = operation.catch(() => {});
-		return operation;
+		} catch (error) {
+			live.transportErrors[key] = error instanceof Error ? error.message : "Native adapter could not start. Reopen this chat to retry.";
+		}
+		return false;
 	}
 	/**
 	* The order saved chats start in, which is the order they take native listeners in (`NATIVE_SLOTS` per transport):
@@ -29446,15 +31412,54 @@ var GhostlyNode = class GhostlyNode {
 			deleted: unique.filter((_, i) => !rows[i])
 		});
 	}
+	/**
+	* At the start, before anything reads a history: received rows an earlier version stored under a time that has not
+	* come yet take a place before now (`settleAhead`). One row is read when nothing is ahead, which is every start but
+	* the first after the update.
+	*/
+	async settleHistory(linkId) {
+		const now = Date.now();
+		const newest = (await db.getMessagePage(linkId, { limit: 1 })).messages[0];
+		if (!newest || newest.timestamp <= now) return;
+		for (const row of settleAhead(await db.getMessages(linkId), now)) await db.putMessage(row);
+	}
+	/**
+	* A new row with its place in its history. A received row takes it here and now, past the last place given in its
+	* chat: the time its sender says is kept beside it (`sentAt`) and shown, and orders nothing (WISP 400, requirement
+	* 10). A sender's clock ahead or behind then moves no message past another, and what I send next goes below what I
+	* just received. A row of mine keeps its own time; one placed already (it has `sentAt`) is left as it is. A line
+	* of a group's history (a membership change, a rename) is not a message: it stays at its commit's time, but never
+	* ahead of this clock nor above a row placed here since the app started. The admin's clock picks that time: two
+	* minutes ahead, "X joined" sat under everything said in the next two minutes; behind, it went above what the
+	* members had just read. Read late with nothing newer here (a member back after a while), it keeps its moment.
+	*/
+	placed(message) {
+		const now = Date.now(), last = this.placedAt.get(message.linkId) ?? 0;
+		if (message.event) {
+			if (message.sender !== "peer") return message;
+			const timestamp = Math.max(Math.min(receivedTimestamp(message.timestamp, now), now), last + 1);
+			this.placedAt.set(message.linkId, timestamp);
+			return {
+				...message,
+				timestamp
+			};
+		}
+		if (message.sender === "peer" && message.sentAt === void 0) {
+			const sentAt = claimedTime(message.timestamp);
+			message = {
+				...message,
+				timestamp: arrivalKey(now, last),
+				...sentAt !== void 0 && { sentAt }
+			};
+			this.placedAt.set(message.linkId, message.timestamp);
+		} else this.placedAt.set(message.linkId, Math.max(last, Math.min(message.timestamp, now)));
+		return message;
+	}
 	async storeMessage(message) {
 		await this.storeNewMessage(message);
 	}
 	/** Stores a message; false when it was there already (or deleted here): nothing new came. */
 	async storeNewMessage(message) {
-		if (message.sender === "peer") message = {
-			...message,
-			timestamp: receivedTimestamp(message.timestamp)
-		};
 		const edge = this.links.get(message.linkId)?.stored;
 		if (edge?.group && edge.groupPeer && !edge.groupEntry) message = {
 			...message,
@@ -29469,6 +31474,7 @@ var GhostlyNode = class GhostlyNode {
 			id: `${message.linkId}:${message.id}`,
 			...message.sender === "peer" ? { member: pay.member } : {}
 		};
+		message = this.placed(message);
 		const live = this.links.get(message.linkId);
 		if (live?.stored.deletedIds?.includes(message.id)) return false;
 		message = await this.resolveReply(message);
@@ -29497,8 +31503,9 @@ var GhostlyNode = class GhostlyNode {
 			};
 		}
 		if (!await db.addMessage(message)) return false;
+		this.clockSample(message);
 		const newest = this.newestAt.get(message.linkId);
-		if (!message.event) this.newestAt.set(message.linkId, Math.max(newest ?? 0, message.timestamp));
+		if (!message.event) this.newestAt.set(message.linkId, Math.max(newest ?? 0, writtenAt(message, this.clockLeads.get(message.linkId))));
 		if (message.sender === "peer") this.messageFeedback("message", message, newest);
 		if (live) live.lastMessageAt = Math.max(live.lastMessageAt, message.timestamp);
 		const early = message.sender === "peer" && message.id.startsWith("peer_") ? this.editBuffer.take(message.linkId, message.id.slice(5)) : void 0;
@@ -29583,7 +31590,7 @@ var GhostlyNode = class GhostlyNode {
 			status: live.status,
 			dataLink: live.dataLink,
 			peerOnline: presence.online,
-			peerLastSeenAt: presence.lastPacketAt,
+			peerLastSeenAt: presenceSeenAt(presence),
 			peerServices: presence.services,
 			lastMessageAt: live.lastMessageAt,
 			peerAck: live.peerAck,
@@ -29672,6 +31679,7 @@ var EngineServer = class {
 			}
 		}, options);
 		this.ready = this.node.start();
+		this.ready.catch(() => {});
 	}
 	attach(client) {
 		this.clients.add(client);
@@ -29697,6 +31705,11 @@ var EngineServer = class {
 				});
 				this.histories.get(client)?.add(link.id);
 			});
+		}, (error) => {
+			this.post(client, {
+				kind: "start-failed",
+				failure: profileOpenFailure(error)
+			});
 		}).catch(() => {
 			this.clients.delete(client);
 		});
@@ -29804,4 +31817,4 @@ function signalKind(signal) {
 //#endregion
 export { EngineServer, hyperdhtRelayProblem as n, server_exports as t };
 
-//# sourceMappingURL=server-C-8wbsAX.js.map
+//# sourceMappingURL=server-BnNXYzR9.js.map