@ghostlytools/cli 1.0.2 → 1.0.3

package/dist/assets/{server-Cajp8VLY.js → server-BnNXYzR9.js}

@@ -1,4 +1,7 @@
-import { $ as boundedIdentityFetch, $i as GROUP_MEMBER_CAP, $n as LIVENESS_PING_MS, $r as IDENTITY_REVOCATION_LABEL, $t as GroupWakeLimiter, A as TEST_MINT, Aa as normalizeRelayUrl, Ai as GROUP_REACTION_FRAME, An as assertTokenUnits, Ar as nextPinNumber, At as transact, B as registeredLightningProviders, Ba as identityFromSeedB64, Bi as pairedReplyAuthor, Bn as isPubkyKey, Br as vapidKeysMatch, Bt as communityHasFrame, C as networkLabel, Ca as createChatInvite, Ci as EDIT_RATE_WINDOW_MS, Cn as ONCHAIN_PROVIDER, Cr as transferEnded, Ct as STORES, D as WALLET_TYPES, Da as DEFAULT_RELAYS, Di as forwardedAgain, Dn as TEST_USDT_FAUCET_AMOUNT, Dt as fileStore, Ea as inviteOwnership, Ei as parseLinkPreview, En as SEPOLIA_TEST_USDT_FAUCET, Er as typingActivity, Et as deleteDatabase, F as paysItsOwnInvoices, Fi as reactionEmoji, Fn as SPARK_NETWORKS, Fr as WakeLimiter, Ft as openGroupTyping, G as SourceConfigError, Ga as randomBytes, Gi as checkStatusCard, Gn as cashuRequestPayload, Gr as HoldKeys, Gt as decodeGroupEntryLink, H as reserveAdapterIds, Ha as sanitizeAvatar, Hi as replySnippet, Hn as engineText, Hr as EDIT_CAPABILITY, Ht as decodeCommunityLink, I as BACKUP_MEDIA_TYPE, Ii as reactionIsNewer, In as SPARK_PROVIDER, Ir as newWakeToken, It as sealGroupTyping, J as networkMode, Ja as utf8Decode, Ji as arrivalKey, Jn as isFederationId, Jr as readManifest, Jt as knockIdentity, K as SourceUnreachableError, Ka as toBase64Url, Ki as sameButtonText, Kn as fedimintRequestPayload, Kr as HoldRefusedError, Kt as encodeGroupEntryLink, L as MAX_BACKUP_BYTES, Li as readReaction, Ln as sparkAddressKind, Lr as relayRequest, Lt as COMMUNITY_LIMITS, M as isTestMint, Ma as isDiscoveryBudgetError, Mi as ReactionWindow, Mn as formatPaymentAmount, Mr as pinNumberHolds, N as isWorthlessMint, Na as withRequestOptions, Ni as nextReactionNumber, Nn as validatePaymentTarget, Nr as readPin, Nt as GroupTypingBoard, O as BITCOIN_INVOICE_ON_TESTNET, Oa as RelayTransport, Oi as readForwarded, On as USDT_PUBLIC_RPC, Or as PIN_LIMITS, Ot as openDb, P as mintNetwork, Pa as PacketTooLargeError, Pi as queueReaction, Pn as walletNetworkOf, Pr as WAKE_CALL_INTERVAL_MS, Pt as groupTypingEpoch, Q as setOwnDidSource, Qi as shownTime, Qn as INVITE_TAKEN, Qr as dialDescriptors, R as identityProviders, Ra as createIdentity, Ri as validReactionNumber, Rn as sparkInvoiceDetails, Rr as wakeRequest, Rt as CommunitySession, S as WrongNetworkError, Sa as OwnInviteError, Si as EDIT_BUFFER_MS, Sn as EVM_TEST_CHAINS, Sr as FILE_LIMITS, T as cashuMint, Ta as encodeInviteCode, Ti as dhtEditId, Tn as SEPOLIA_TEST_USDT, Tr as TypingSender, Tt as databaseName, U as NothingSpentError, Ua as bytesEqual, Ui as BUTTON_ID, Un as decodeBolt11, Ur as HOLD_CAPABILITY, Ut as encodeCommunityLink, V as registeredOnchainProviders, Va as publicKeyFromZ32, Vi as readReply, Vn as engineError, Vt as communityMessageId, W as PROVIDER_PLATFORMS, Wa as fromBase64Url, Wi as STATUS_CARD_LIMITS, Wn as ENDPOINT, Wr as HOLD_LIMITS, X as assertPublicServer, Xa as __exportAll, Xi as heardTime, Xn as parseFedimintRequestPayload, Xr as DHT_TEXT_CAPABILITY, Xt as mergeKnocks, Y as redact, Ya as utf8Encode, Yi as claimedTime, Yn as parseCashuRequestPayload, Yr as CapsExchange, Yt as knockRecords, Z as resolveAtprotoDid, Zi as receivedTimestamp, Zn as GhostLink, Zr as capsDescriptors, Zt as readKnocks, _ as newDeviceKey, _a as parseCallSignal, _i as fileMessageText, _n as didDhtFromPublicKey, _r as readBeacon, _t as fileBytes, a as createFailure, aa as DirectPathWatch, ai as receivedIdentityStatus, an as GroupSession, ar as COMMUNITY_TOPOLOGY, at as replyRef, b as ModeChanged, ba as LEGACY_SERVICES, bi as DHT_MESSAGE_TTL, bn as signDidDhtPacket, br as shouldBeHub, bt as removeFileBytes, c as paymentNetwork, ca as traceLink, ci as PeerProofs, cr as doorHubs, ct as paymentWireId, d as networkReason, da as parseLocalTarget, di as TRANSPORTS, dn as parseCommunityEdit, dr as lobbyRecords, dt as removeStored, ei as IdentityExchange, en as groupWakeFrame, er as pairedMessageFrame, et as verifyIdentity, f as rpcHost, fa as webLocalFetch, fi as automaticTransport, fn as mentionsMember, fr as mergeBeacon, ft as storedSize, g as intentRepository, ga as RTC_CONFIG, gi as safeBlobType, gn as didDhtDocument, gr as rankHubs, h as ProviderSources, ha as encodeControl, hi as parseImageMeta, hn as normalizeAtprotoHandle, hr as pickHubs, ht as blobDigest, i as assertConfirmedReal, ia as edgeParams, ii as newIdentityBinding, in as GROUP_READ_NOTE, ir as pickMeshHubs, it as receivedPairedReply, j as fakesLightning, ja as budgetRetryMs, ji as REACTION_LIMITS, jn as assertWholeSats, jr as pinIsNewer, jt as wrap, k as DEFAULT_MINTS, ka as currentRelays, ki as COMMUNITY_REACTION_FRAME, kn as WALLET_NETWORKS, kr as mayPin, kt as store, l as paymentNetworksOf, la as GhostlyHttpError, li as emptyProofLedger, ln as GROUP_EDIT_TEXT_BYTES, lr as freshHubs, lt as FileAppender, m as LightningCards, ma as decodeControl, mi as irohRelayUrl, mn as isAtprotoDid, mr as newerHead, n as loadFedimintSdk, na as rosterHas, ni as identityRevocationValue, nn as parseGroupWakeFrame, nr as mayBeHub, nt as groupReply, o as createTiming, oi as revokesIdentity, on as groupMessageId, or as beaconKeys, ot as replyTo, p as CASHU_CARD, pa as LIMITS, pi as irohDescriptor, pn as groupName, pr as mergeLobby, pt as streamStored, q as isNothingSpentError, qa as toZ32, qi as statusCardText, qn as findEndpoint, qr as newMailbox, qt as entryParams, r as WALLET_NAMES, ra as verifyCommitSignature, ri as identityStatement, rr as meshHubs, rt as pairedWireReply, s as crossNetwork, sa as RELAY_POLL_INTERVALS, si as lastSharedWithMe, sr as beaconRecords, st as paymentAlias, t as fedimintDatabase, ta as MEMBER_KEY, ti as emptyIdentityLedger, tn as groupWakes, tr as MESH_HUBS, tt as chosenResolver, u as walletInstances, ua as formatLocalTarget, ui as validExternalKey, un as carryMentions, ur as lobbyKeys, ut as readStored, v as sealSeed, va as emptyLinkRecords, vi as parseVoiceMeta, vn as encodeDidDhtDeactivated, vr as readBeaconHead, vt as fileBytesOf, w as CASHU_MINT_SOURCE, wa as decodeInviteCode, wi as RateWindow, wn as PaymentPreflightError, wr as transferStalled, wt as clearProfileStores, x as ModeGate, xa as serviceIdFromName, xi as peekDhtMailbox, xn as ETHEREUM_USDT, xr as ChatFiles, y as unsealSeed, ya as HTTP_SERVICE_PROTO, yi as parseVideoMeta, yn as encodeDidDhtPacket, yr as readLobby, z as onAdaptersChanged, za as identityFromSeed, zi as wireReaction, 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,
@@ -11531,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
@@ -11570,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) {
@@ -11798,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,
@@ -11822,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) }
@@ -12287,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;
@@ -12301,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;
@@ -12339,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) {
@@ -12372,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);
@@ -12412,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") {
@@ -12446,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) {
@@ -12507,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);
 	}
@@ -12516,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);
@@ -12764,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"}`,
@@ -12789,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)
 	};
 }
@@ -12812,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
 		};
@@ -13287,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");
@@ -13771,6 +14140,16 @@ var FAREWELL_SAY_MS = 1e4;
 * 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}`;
@@ -13841,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) {
@@ -14185,6 +14565,7 @@ var Communities = class {
 			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);
@@ -14237,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");
@@ -14247,12 +14629,37 @@ 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);
@@ -14260,6 +14667,7 @@ var Communities = class {
 		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;
@@ -14271,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) {
@@ -14340,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);
@@ -14383,6 +14830,7 @@ 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);
@@ -14391,13 +14839,63 @@ var Communities = class {
 			live.beaconFailedAt = now;
 			live.beaconAskedAt ||= now;
 			if (live.session.roster.length === 1 || now - live.beaconAskedAt >= COMMUNITY_TOPOLOGY.beaconFreshMs) live.beaconKnown = true;
-			return;
+			return false;
 		}
 		live.beaconFailedAt = 0;
 		live.beaconKnown = true;
-		live.beacon = readBeacon(keys, records ?? []);
+		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
@@ -14422,7 +14920,7 @@ var Communities = class {
 			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 = readBeacon(keys, records);
+			existing = this.inMyTime(live, readBeacon(keys, records), now);
 			head = readBeaconHead(keys, records);
 		}
 		const hubs = mergeBeacon(existing, live.session.myKey, listed ? {
@@ -14432,12 +14930,12 @@ 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;
 	}
@@ -14515,10 +15013,11 @@ 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) {
@@ -14712,9 +15211,15 @@ var Communities = class {
 			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) {
@@ -14824,6 +15329,12 @@ 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);
@@ -14881,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) {
@@ -14923,9 +15436,7 @@ var Communities = class {
 				group.community = next;
 				await this.store.putGroup(group);
 			},
-			broadcast: (frame) => {
-				for (const [, linkId] of this.hearers(id, frame)) 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);
 			},
@@ -14956,7 +15467,7 @@ var Communities = class {
 					...m.forwarded && { forwarded: m.forwarded },
 					...m.card && { card: m.card }
 				});
-				const came = m.sender === session.myKey ? timestamp : 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));
@@ -14985,10 +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,
@@ -15474,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 {}
@@ -15568,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++;
@@ -15581,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":
@@ -15668,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}`;
@@ -15721,6 +16246,13 @@ function eventTime(taken, groupId, timestamp) {
 	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
@@ -15763,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;
@@ -15853,6 +16392,15 @@ var Groups = class {
 	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();
 	/**
@@ -16216,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);
@@ -16248,14 +16798,127 @@ 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);
+		}
+	}
+	/** 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
+		}]]);
+	}
+	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);
@@ -16297,6 +16960,8 @@ var Groups = class {
 		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);
@@ -16428,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);
@@ -16449,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);
@@ -16496,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);
@@ -16650,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);
 				}
@@ -16698,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);
@@ -16705,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);
@@ -16738,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);
@@ -16746,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;
@@ -16834,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());
@@ -16843,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();
@@ -16962,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);
@@ -16985,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);
@@ -17008,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) {
@@ -17036,7 +17759,7 @@ 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);
-				const came = m.sender === session.myKey ? timestamp : 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));
@@ -17110,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) {
@@ -17160,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";
@@ -17168,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 } : {}
 	};
 }
@@ -18338,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, {
@@ -18536,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 = [];
@@ -18552,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
@@ -18573,7 +19296,7 @@ var HoldEngine = class {
 		}
 		const pointer = {
 			rev: hold.pointerRev + 1,
-			issued: now,
+			issued: dated,
 			expires,
 			manifestUrl,
 			top: hold.outSeq,
@@ -18650,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;
@@ -19685,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 {
@@ -19960,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;
@@ -19969,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 {
@@ -20004,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(),
@@ -20037,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
@@ -20052,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. */
@@ -20065,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);
@@ -20232,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,
@@ -20245,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([
@@ -20286,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();
@@ -20366,18 +21195,41 @@ var CashuWallet = class {
 		const keep = (prepared.swap.keepOutputs ?? []).map(OutputData.deserialize);
 		const send = (prepared.swap.sendOutputs ?? []).map(OutputData.deserialize);
 		const outputs = [...keep, ...send];
-		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;
-		const keys = (await wallet.mint.getKeys()).keysets;
-		const restored = [];
-		for (const output of outputs) {
-			const index = recovered.outputs.findIndex((o) => o.B_ === output.blindedMessage.B_);
+		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 === 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) {
+			const index = recovered.outputs.findIndex((o) => o.B_ === output.blindedMessage.B_);
 			const signature = recovered.signatures[index];
 			const key = signature && keys.find((k) => k.id === signature.id);
 			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({
@@ -20434,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);
@@ -20453,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) => ({
@@ -20508,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,
@@ -20527,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");
@@ -20557,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 {
@@ -20574,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 = {
@@ -20589,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 {
@@ -20608,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;
 			}
@@ -20619,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);
@@ -20631,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();
 			}
@@ -20665,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,
@@ -20680,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. */
@@ -20708,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);
@@ -20771,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);
@@ -21456,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",
@@ -21767,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,
@@ -21811,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") {
@@ -23328,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 }) {
@@ -23767,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. */
@@ -23843,6 +25206,11 @@ var GhostlyNode = class GhostlyNode {
 	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.
@@ -23891,11 +25259,21 @@ var GhostlyNode = class GhostlyNode {
 	newestAt = /* @__PURE__ */ new Map();
 	/** 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,
-			timestamp: shownTime(message)
+			timestamp: writtenAt(message, this.clockLeads.get(message.linkId))
 		}, {
 			startedAt: this.feedbackStartedAt,
 			newest,
@@ -23947,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(),
@@ -24113,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() {
@@ -24168,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);
@@ -24594,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) => {
@@ -24630,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, {
@@ -24717,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
@@ -24736,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);
@@ -24760,12 +26147,46 @@ var GhostlyNode = class GhostlyNode {
 			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;
@@ -24782,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() {
@@ -24865,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,
@@ -25018,6 +26444,7 @@ 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();
@@ -25087,6 +26514,8 @@ var GhostlyNode = class GhostlyNode {
 		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);
@@ -25156,6 +26585,7 @@ var GhostlyNode = class GhostlyNode {
 				...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),
@@ -25236,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 {
@@ -25263,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 {
@@ -25288,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;
@@ -25591,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;
@@ -25646,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;
@@ -25670,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;
@@ -25689,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,
@@ -26338,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) => {
@@ -26367,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;
@@ -26745,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}`);
@@ -26782,6 +28249,7 @@ var GhostlyNode = class GhostlyNode {
 				size: file.size
 			});
 			const source = streamStored(stored);
+			said();
 			await link.sendFile({
 				id: wireId,
 				name: file.name,
@@ -26794,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);
@@ -26823,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)) {
@@ -27491,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({
@@ -27557,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);
@@ -27642,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",
@@ -27857,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;
@@ -27875,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();
@@ -28555,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);
@@ -28692,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) {
@@ -28782,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. */
@@ -28822,6 +30351,7 @@ var GhostlyNode = class GhostlyNode {
 		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)) {
@@ -28943,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,
@@ -28985,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 ? {
@@ -29001,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(() => {});
@@ -29031,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) => {
@@ -29061,7 +30594,8 @@ var GhostlyNode = class GhostlyNode {
 				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" };
@@ -29350,6 +30884,10 @@ var GhostlyNode = class GhostlyNode {
 					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;
@@ -29487,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);
@@ -29578,7 +31117,7 @@ var GhostlyNode = class GhostlyNode {
 	get nativeFactories() {
 		const relay = this.relaysHyperdht ? this.hyperdhtRelay : "";
 		return {
-			...relay ? { "hyperdht/1": async (seedB64) => (await import("./hyperdhtRelay-cMlRWrmD.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 }) } : {}
 		};
@@ -29889,14 +31428,22 @@ var GhostlyNode = class GhostlyNode {
 	* 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, as before.
+	* 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) return message.sender === "peer" ? {
-			...message,
-			timestamp: receivedTimestamp(message.timestamp)
-		} : message;
+		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 = {
@@ -29956,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, shownTime(message)));
+		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;
@@ -30042,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,
@@ -30131,6 +31679,7 @@ var EngineServer = class {
 			}
 		}, options);
 		this.ready = this.node.start();
+		this.ready.catch(() => {});
 	}
 	attach(client) {
 		this.clients.add(client);
@@ -30156,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);
 		});
@@ -30263,4 +31817,4 @@ function signalKind(signal) {
 //#endregion
 export { EngineServer, hyperdhtRelayProblem as n, server_exports as t };
 
-//# sourceMappingURL=server-Cajp8VLY.js.map
+//# sourceMappingURL=server-BnNXYzR9.js.map