@ghostlytools/cli 1.3.10 → 1.4.0

package/dist/assets/{server-C-EkLCCt.js → server-Cd1dLOB8.js}

@@ -1,27 +1,26 @@
 import { n as traceJoin } from "./joinTrace-CjRDFy85.js";
-import { $c as currentRelays, $i as revokesIdentity, $n as GROUP_FILE_LIMITS, $r as WAKE_CALL_INTERVAL_MS, $t as didDhtFromPublicKey, A as CommunitySession, Aa as forwardedAgain, Ac as devicePingFrame, Ao as rosterAdmin, Ar as newerHead, As as handoffOfferFrame, B as knockRecords, Ba as readReaction, Bc as TURN_MAX, Bi as capsDescriptors, Bn as findEndpoint, Bo as GhostlyHttpError, Br as transferStalled, Bs as readHandoffHave, C as sha256Paced, Ca as parseImageMeta, Cc as DEVICES_CAPABILITY, Ci as readManifest, Cl as randomBytes, Cn as isBitcoinAddress, Cr as beaconRecords, Cs as handoffContext, D as openGroupTyping, Da as RateWindow, Dc as deviceEchoNonce, Dl as utf8Encode, Do as MEMBER_KEY, Dr as lobbyRecords, Ds as handoffEphemeral, E as groupTypingEpoch, Ea as EDIT_RATE_WINDOW_MS, Ec as deviceEchoFrame, El as utf8Decode, Er as lobbyKeys, Es as handoffDigest, Et as normalizeAtprotoHandle, Fa as ReactionWindow, Fc as TURN_RAISE_READ_TIMEOUT_MS, Fr as readLobby, Fs as handoffVersions, G as groupWakeFrame, Ga as replySnippet, Gc as signTurnRelease, Gn as INVITE_TAKEN, Go as decodeControl, Gr as typingActivity, Gs as sealHandoffPiece, H as readKnocks, Ha as wireReaction, Hc as nextTurnPosition, Hn as parseCashuRequestPayload, Ho as parseLocalTarget, Hs as readHandoffPake, I as decodeGroupEntryLink, Ia as nextReactionNumber, Ic as TURN_SETTLE_MS, In as decodeBolt11, Io as DHT_POLL_INTERVALS, Ir as shouldBeHub, Is as newHandoffId, J as GROUP_LIMITS, Jc as turnName, Ji as emptyIdentityLedger, Jn as pairedMessageFits, Jo as RTC_CONFIG, Jr as mayPin, Js as readSetUpdate, K as groupWakes, Ka as BUTTON_ID, Kc as turnInstance, Ki as IdentityExchange, Kn as LIVENESS_PING_MS, Ko as encodeControl, L as encodeGroupEntryLink, La as queueReaction, Lc as classifyTurnRead, Ln as ENDPOINT, Lr as ChatFiles, Ls as readHandoffAck, M as communityHasFrame, Ma as COMMUNITY_REACTION_FRAME, Mc as seedSigner, Mo as verifyCommitSignature, Mr as rankHubs, Ms as handoffReleaseFrame, N as decodeCommunityLink, Na as GROUP_REACTION_FRAME, Nc as webCryptoSigner, No as edgeParams, Nr as readBeacon, Ns as handoffRetryAfter, O as sealGroupTyping, Oa as dhtEditId, Oc as deviceKeyZ32, Oo as commitHash, Or as mergeBeacon, Os as handoffHelloFrame, P as encodeCommunityLink, Pa as REACTION_LIMITS, Po as DirectPathWatch, Pr as readBeaconHead, Ps as handoffStreamKey, Q as frameBytes, Qc as RelayTransport, Qi as receivedIdentityStatus, Qn as parseEngineError, Qr as readPin, Qs as verifySetUpdate, Qt as didDhtDocument, R as entryParams, Ra as reactionEmoji, Rc as turnPutSummary, Ri as CapsExchange, Rn as cashuRequestPayload, Ro as RELAY_POLL_INTERVALS, Rr as FILE_LIMITS, Rs as readHandoffCancel, S as readAppBundleAsync, Sa as parseVideoMeta, Si as newMailbox, Sn as sparkInvoiceDetails, So as canonicalJson, Sr as beaconKeys, Ss as handoffCancelFrame, T as GroupTypingBoard, Ta as EDIT_BUFFER_MS, Tc as HANDOFF_CAPABILITY, Tl as toZ32, Tn as isPubkyKey, To as GROUP_MEMBER_CAP, Tr as freshHubs, Ts as handoffDataFrame, Tt as isAtprotoDid, Ua as pairedReplyAuthor, Uc as readTurnPacket, Un as parseFedimintRequestPayload, Uo as webLocalFetch, Ur as TypingSender, Us as readHandoffTurnFrame, V as mergeKnocks, Va as validReactionNumber, Vc as firstDeviceSetSecret, Vi as dialDescriptors, Vn as isFederationId, Vo as formatLocalTarget, Vs as readHandoffHello, W as GroupWakeLimiter, Wa as readReply, Wc as signTurnPacket, Wi as IDENTITY_REVOCATION_LABEL, Wn as GhostLink, Wo as LIMITS, Ws as readHandoffVerified, X as GROUP_READ_NOTE, Xc as turnVerifierMark, Xi as identityStatement, Xn as engineError, Xr as pinIsNewer, Xs as setUpdateFrame, Yc as turnStatedVerifier, Yi as identityRevocationValue, Yn as pairedMessageFrame, Yr as nextPinNumber, Ys as setAckFrame, Z as GroupSession, Za as STATUS_CARD_LIMITS, Zc as DEFAULT_RELAYS, Zi as newIdentityBinding, Zn as engineText, Zr as pinNumberHolds, Zs as signTombstone, _c as createChatInvite, _i as HOLD_DATED_BACK_MS, _n as validatePaymentTarget, _o as isAppRef, _r as MESH_HUBS, _s as filePartName, a as planAppUpdate, aa as automaticTransport, ac as enrollDigits, ai as wakeRequest, al as withRequestOptions, an as EVM_TEST_CHAINS, ao as arrivalKey, as as serviceIdFromName, at as groupName, b as pacer, ba as parseVoiceMeta, bi as HoldRefusedError, bl as bytesEqual, bn as SPARK_PROVIDER, br as pickMeshHubs, bs as handoffAttemptSucceeded, cc as enrollHelloFrame, cl as createRelayPayload, cn as SEPOLIA_TEST_USDT, co as receivedTimestamp, cs as HANDOFF_DONE, d as APP_BUNDLE_LIMITS, da as DHT_FILE_CAPABILITY, dc as readEnrollHello, di as APPS_CAPABILITY, dn as USDT_PUBLIC_RPC, do as APP_STATEMENT_LIMITS, ds as HANDOFF_OFFER, ea as lastSharedWithMe, ei as WakeLimiter, el as normalizeRelayUrl, en as encodeDidDhtDeactivated, es as parseCallSignal, f as APP_BUNDLE_MAGIC, fa as dhtFileId, fc as verifyEnrollProof, fi as BUTTONS_CAPABILITY, fl as createIdentity, fn as WALLET_NETWORKS, fo as appFingerprint, fs as HANDOFF_PAKE, g as appViewOf, gc as OwnInviteError, gi as HOLD_CAPABILITY, gl as verify, gn as formatPaymentAmount, go as isAppKey, gr as readGroupSignal, gs as HANDOFF_VERIFIED, h as appDigest, ha as sanitizeMime, hc as readDeviceInvite, hi as UPGRADE_CAPABILITY, hl as publicKeyFromZ32, hn as assertWholeSats, ho as isAppHash, hr as groupSignalFrame, hs as HANDOFF_TIMINGS, i as checkAppBeforeRun, ia as TRANSPORTS, ic as enrollCancelReason, ii as relayRequest, il as isDiscoveryBudgetError, in as ETHEREUM_USDT, io as statusCardText, ir as groupFileFallback, is as LEGACY_SERVICES, it as mentionsMember, j as GROUP_READ_NOTE_COMMUNITY, ja as readForwarded, jc as newDeviceSetSecret, jo as rosterHas, jr as pickHubs, js as handoffPakeFrame, k as COMMUNITY_LIMITS, ka as parseLinkPreview, kc as deviceLinkPairing, ko as parseGroupCommit, kr as mergeLobby, ks as handoffManifestFrames, l as readAppStoreSteps, la as DHT_MESSAGE_TTL, lc as enrollProofFrame, li as chatAppId, lo as shownTime, ls as HANDOFF_HAVE, ma as sanitizeFileName, mc as deviceInviteJoinerParams, mi as STATUS_CARD_CAPABILITY, ml as identityFromSeedB64, mn as assertTokenUnits, ms as HANDOFF_REQUEST, n as appStoreDecision, na as emptyProofLedger, ni as newWakeToken, nl as traceLink, no as checkStatusCard, ns as emptyLinkRecords, nt as carryMentions, o as APP_STORE_LIMITS, oc as enrollDoneFrame, oi as checkPushEndpoint, ol as PacketTooLargeError, on as ONCHAIN_PROVIDER, oo as claimedTime, or as readGroupFileMeta, os as HANDOFF_ACK, p as APP_ICON_PATH, pa as formatFileSize, pc as createDeviceInvite, pi as EDIT_CAPABILITY, pl as identityFromSeed, pn as arkAddressPrefix, po as appRef, ps as HANDOFF_PIECE_BYTES, q as parseGroupWakeFrame, qc as turnKeys, qn as PAIRED_FRAME_TOO_LARGE, qr as PIN_LIMITS, r as appUpdateDecision, ra as validExternalKey, rc as enrollCancelFrame, ri as parseWakeFrame, rl as budgetRetryMs, rn as signDidDhtPacket, ro as sameButtonText, rs as HTTP_SERVICE_PROTO, rt as parseCommunityEdit, sc as enrollGrantFrame, si as vapidKeysMatch, sn as PaymentPreflightError, so as heardTime, ss as HANDOFF_CANCEL, t as appRevocationFor, ta as PeerProofs, ti as deviceWakeRequest, tn as encodeDidDhtPacket, tt as GROUP_EDIT_TEXT_BYTES, ua as peekDhtMailbox, uc as readEnrollGrant, ui as isAppVersion, un as TEST_USDT_FAUCET_AMOUNT, ur as CarriedTransport, us as HANDOFF_HELLO, vc as decodeInviteCode, vi as HOLD_LIMITS, vl as sanitizeAvatar, vn as walletNetworkOf, vo as readAppRevocation, vr as mayBeHub, vs as handoffAttemptAllowed, wc as ENROLL_CAPABILITY, wl as toBase64Url, wo as readCanonicalJson, wr as doorHubs, ws as handoffContextProof, xc as inviteOwnership, xi as isHoldUrl, xl as fromBase64Url, xn as sparkAddressKind, xr as COMMUNITY_TOPOLOGY, xs as handoffBusyFrame, y as isAppUrl, ya as fileMessageText, yc as encodeInviteCode, yi as HoldKeys, yl as sanitizeDisplayText, yn as SPARK_NETWORKS, yr as meshHubs, ys as handoffAttemptFailed, z as knockIdentity, za as reactionIsNewer, zc as TURN_LAST_SEQUENCE, zi as DHT_TEXT_CAPABILITY, zn as fedimintRequestPayload, zo as presenceSeenAt, zr as transferEnded, zs as readHandoffDone } from "./src-Dg1bvMNv.js";
+import { $a as GROUP_MEMBER_CAP, $c as DEVICES_CAPABILITY, $i as DHT_MESSAGE_TTL, $l as randomBytes, $o as handoffContextProof, $r as chatAppId, $s as knockSlotIdentity, A as knockRecords, Aa as wireReaction, Ac as isAppRef, Ai as capsDescriptors, Al as normalizeRelayUrl, An as findEndpoint, Ar as transferStalled, B as GROUP_READ_NOTE, Bc as createContactLink, Bi as identityStatement, Bn as engineError, Bo as HANDOFF_OFFER, Br as pinIsNewer, Bs as readEnrollHello, C as decodeCommunityLink, Ca as ReactionWindow, Cl as turnKeys, Co as RTC_CONFIG, Cr as readBeacon, Cs as readSetUpdate, D as encodeGroupEntryLink, Da as reactionIsNewer, Dl as DEFAULT_RELAYS, Dn as ENDPOINT, Dr as ChatFiles, Ds as verifySetUpdate, E as decodeGroupEntryLink, Ea as reactionEmoji, Ec as appRef, El as turnVerifierMark, En as decodeBolt11, Er as shouldBeHub, Es as signTombstone, F as groupWakeFrame, Fc as parseImageMeta, Fl as withRequestOptions, Fn as INVITE_TAKEN, Fo as HANDOFF_ACK, Fr as typingActivity, Fs as enrollDoneFrame, G as GROUP_EDIT_TEXT_BYTES, Ga as sameButtonText, Gc as readDeviceInvite, Gi as PeerProofs, Gl as publicKeyFromZ32, Go as HANDOFF_VERIFIED, Gr as deviceWakeRequest, Gs as newInbox, Gt as encodeDidDhtPacket, H as frameBytes, Hc as readContactLink, Hi as receivedIdentityStatus, Hl as createIdentity, Hn as parseEngineError, Ho as HANDOFF_PIECE_BYTES, Hr as readPin, Hs as clearMissed, Ht as didDhtDocument, I as groupWakes, Ii as IdentityExchange, Il as PacketTooLargeError, In as LIVENESS_PING_MS, Io as HANDOFF_CANCEL, Is as enrollGrantFrame, J as mentionsMember, Ja as claimedTime, Jc as decodeInviteCode, Ji as TRANSPORTS, Jl as sanitizeAvatar, Jn as groupFileFallback, Jo as handoffAttemptFailed, Jr as relayRequest, Js as takeRequest, Jt as ETHEREUM_USDT, K as carryMentions, Ka as statusCardText, Kc as OwnInviteError, Ki as emptyProofLedger, Kl as verify, Ko as filePartName, Kr as newWakeToken, Ks as planKnocks, L as parseGroupWakeFrame, Lc as canonicalJson, Ln as PAIRED_FRAME_TOO_LARGE, Lo as HANDOFF_DONE, Lr as PIN_LIMITS, Ls as enrollHelloFrame, M as readKnocks, Ma as readReply, Ml as traceLink, Mn as parseCashuRequestPayload, Mo as HTTP_SERVICE_PROTO, Ms as enrollCancelFrame, Na as replySnippet, Nl as budgetRetryMs, Nn as parseFedimintRequestPayload, No as LEGACY_SERVICES, Nr as TypingSender, Ns as enrollCancelReason, O as entryParams, Oa as readReaction, Oc as isAppHash, Oi as CapsExchange, Ol as RelayTransport, On as cashuRequestPayload, Or as FILE_LIMITS, P as GroupWakeLimiter, Pa as BUTTON_ID, Pi as IDENTITY_REVOCATION_LABEL, Pl as isDiscoveryBudgetError, Pn as GhostLink, Po as serviceIdFromName, Ps as enrollDigits, Qa as GROUP_ADMIN_OFF_ERROR, Qo as handoffContext, Qs as contactDay, Qt as SEPOLIA_TEST_USDT, R as GROUP_LIMITS, Ri as emptyIdentityLedger, Rl as createRelayPayload, Rn as pairedMessageFits, Ro as HANDOFF_HAVE, Rr as mayPin, Rs as enrollProofFrame, S as communityHasFrame, Sa as REACTION_LIMITS, Sc as sha256Paced, Sl as turnInstance, Sr as rankHubs, Ta as queueReaction, Tc as appFingerprint, Tl as turnStatedVerifier, Tr as readLobby, Ts as setUpdateFrame, Uc as createDeviceInvite, Ui as revokesIdentity, Ul as identityFromSeed, Un as GROUP_FILE_LIMITS, Uo as HANDOFF_REQUEST, Ur as WAKE_CALL_INTERVAL_MS, Us as endedRequests, Ut as didDhtFromPublicKey, V as GroupSession, Vc as encodeContactLink, Vi as newIdentityBinding, Vn as engineText, Vo as HANDOFF_PAKE, Vr as pinNumberHolds, Vs as verifyEnrollProof, Wa as checkStatusCard, Wc as deviceInviteJoinerParams, Wi as lastSharedWithMe, Wl as identityFromSeedB64, Wo as HANDOFF_TIMINGS, Wr as WakeLimiter, Ws as inboxRecord, Wt as encodeDidDhtDeactivated, Xa as receivedTimestamp, Xc as inviteLink, Xl as bytesEqual, Xn as readGroupFileMeta, Xo as handoffBusyFrame, Xr as checkPushEndpoint, Xs as ContactRequestError, Xt as ONCHAIN_PROVIDER, Y as groupName, Ya as heardTime, Yc as encodeInviteCode, Yi as automaticTransport, Yl as sanitizeDisplayText, Yo as handoffAttemptSucceeded, Yr as wakeRequest, Ys as turnOff, Yt as EVM_TEST_CHAINS, Za as shownTime, Zc as inviteOwnership, Zl as fromBase64Url, Zo as handoffCancelFrame, Zr as vapidKeysMatch, Zs as REQUEST_LIFETIME_MS, Zt as PaymentPreflightError, _ as openGroupTyping, _a as parseLinkPreview, _l as firstDeviceSetSecret, _o as parseLocalTarget, _r as lobbyRecords, _s as readHandoffPake, a as appStoreDecision, aa as sanitizeMime, ac as openRequest, ai as UPGRADE_CAPABILITY, al as deviceLinkPairing, an as assertWholeSats, ao as rosterHas, ar as groupSignalFrame, as as handoffOfferFrame, b as CommunitySession, ba as COMMUNITY_REACTION_FRAME, bl as signTurnPacket, bo as decodeControl, br as newerHead, bs as sealHandoffPiece, c as planAppUpdate, cc as requestRecords, ci as HOLD_LIMITS, cl as seedSigner, cn as walletNetworkOf, co as DirectPathWatch, cr as mayBeHub, cs as handoffRetryAfter, dc as APP_BUNDLE_MAGIC, di as isHoldUrl, dl as TURN_RAISE_READ_TIMEOUT_MS, dn as sparkAddressKind, dr as COMMUNITY_TOPOLOGY, ds as newHandoffId, ea as peekDhtMailbox, ec as knockSlotOf, ei as isAppVersion, el as ENROLL_CAPABILITY, en as TEST_USDT_FAUCET_AMOUNT, er as CarriedTransport, es as handoffDataFrame, eu as toBase64Url, f as readAppStoreSteps, fa as parseVideoMeta, fc as APP_ICON_PATH, fi as newMailbox, fl as TURN_SETTLE_MS, fn as sparkInvoiceDetails, fo as RELAY_POLL_INTERVALS, fr as beaconKeys, fs as readHandoffAck, g as groupTypingEpoch, ga as dhtEditId, gl as TURN_MAX, go as formatLocalTarget, gr as lobbyKeys, gs as readHandoffHello, gt as normalizeAtprotoHandle, h as GroupTypingBoard, ha as RateWindow, hc as appViewOf, hl as TURN_LAST_SEQUENCE, hn as isPubkyKey, ho as GhostlyHttpError, hr as freshHubs, hs as readHandoffHave, ht as isAtprotoDid, i as appRevocationFor, ia as sanitizeFileName, ic as mergeContactKnocks, ii as STATUS_CARD_CAPABILITY, il as deviceKeyZ32, in as assertTokenUnits, io as rosterAdmin, is as handoffManifestFrames, j as mergeKnocks, ja as pairedReplyAuthor, jc as readAppRevocation, ji as dialDescriptors, jn as isFederationId, jo as emptyLinkRecords, k as knockIdentity, ka as validReactionNumber, kc as isAppKey, ki as DHT_TEXT_CAPABILITY, kl as currentRelays, kn as fedimintRequestPayload, ko as parseCallSignal, kr as transferEnded, l as APP_STORE_LIMITS, la as fileMessageText, lc as seenEntry, li as HoldKeys, ll as webCryptoSigner, ln as SPARK_NETWORKS, lr as meshHubs, ls as handoffStreamKey, ma as EDIT_RATE_WINDOW_MS, mc as appDigest, ml as turnPutSummary, mo as presenceSeenAt, mr as doorHubs, ms as readHandoffDone, n as readX401SdJwtVc, na as dhtFileId, nc as linkRecords, ni as BUTTONS_CAPABILITY, nl as deviceEchoFrame, nn as WALLET_NETWORKS, no as commitHash, ns as handoffEphemeral, nu as utf8Decode, o as appUpdateDecision, oc as readKnockSlot, oi as HOLD_CAPABILITY, ol as devicePingFrame, on as formatPaymentAmount, oo as verifyCommitSignature, or as readGroupSignal, os as handoffPakeFrame, pa as EDIT_BUFFER_MS, pi as readManifest, pl as classifyTurnRead, pn as isBitcoinAddress, po as WATCH_PEER_MS, pr as beaconRecords, ps as readHandoffCancel, q as parseCommunityEdit, qa as arrivalKey, qc as createChatInvite, qi as validExternalKey, qo as handoffAttemptAllowed, qr as parseWakeFrame, qs as settleRequest, qt as signDidDhtPacket, r as sameX401HolderJwk, ra as formatFileSize, rc as makeStampPaced, ri as EDIT_CAPABILITY, rl as deviceEchoNonce, rn as arkAddressPrefix, ro as parseGroupCommit, rs as handoffHelloFrame, ru as utf8Encode, s as checkAppBeforeRun, sc as readLinkRecord, si as HOLD_DATED_BACK_MS, sl as newDeviceSetSecret, sn as validatePaymentTarget, so as edgeParams, sr as MESH_HUBS, ss as handoffReleaseFrame, t as newX401HolderKey, ta as DHT_FILE_CAPABILITY, tc as knockSlotRecords, ti as APPS_CAPABILITY, tl as HANDOFF_CAPABILITY, tn as USDT_PUBLIC_RPC, to as MEMBER_KEY, ts as handoffDigest, tu as toZ32, ua as parseVoiceMeta, uc as APP_BUNDLE_LIMITS, ui as HoldRefusedError, un as SPARK_PROVIDER, uo as DHT_POLL_INTERVALS, ur as pickMeshHubs, us as handoffVersions, v as sealGroupTyping, va as forwardedAgain, vc as isAppUrl, vl as nextTurnPosition, vo as webLocalFetch, vr as mergeBeacon, vs as readHandoffTurnFrame, w as encodeCommunityLink, wa as nextReactionNumber, wc as APP_STATEMENT_LIMITS, wl as turnName, wr as readBeaconHead, ws as setAckFrame, x as GROUP_READ_NOTE_COMMUNITY, xa as GROUP_REACTION_FRAME, xc as readAppBundleAsync, xl as signTurnRelease, xo as encodeControl, xr as pickHubs, y as COMMUNITY_LIMITS, ya as readForwarded, yc as pacer, yl as readTurnPacket, yo as LIMITS, yr as mergeLobby, ys as readHandoffVerified, za as STATUS_CARD_LIMITS, zc as readCanonicalJson, zi as identityRevocationValue, zn as pairedMessageFrame, zo as HANDOFF_HELLO, zr as nextPinNumber, zs as readEnrollGrant } from "./src-DzXL-GYu.js";
 import { i as SourceUnreachableError, n as PROVIDER_PLATFORMS, o as isNothingSpentError, r as SourceConfigError, t as NothingSpentError, u as redact } from "./types-C4_KafL_.js";
 import { t as bitcoindRpc } from "./bitcoindProvider-DGw3xBSa.js";
-import { t as nwc } from "./nwcProvider-D482SQ1a.js";
-import { a as clearProfileStores, c as fileStore, d as profileOpenFailure, f as store, i as STORES$1, l as newestWalletTx, m as wrap, n as APP_STORAGE_SCOPE_INDEX, o as databaseName, p as transact, r as CARD_INDEX, s as deleteDatabase, t as APP_STORAGE_CHAT_INDEX, u as openDb } from "./idb-B5L8wuOm.js";
-import { a as sealSeed, i as newDeviceKey, o as unsealSeed, r as intentRepository } from "./networkReason-vUHo6A_C.js";
-import { $ as setSingleWriterGate, A as LightningCards, B as breezDatabaseInUse, C as FileAppender, D as streamStored, E as storedSize, F as ProviderSources, G as ModeChanged, H as dropBreezDatabase, I as sourceKey, J as networkLabel, K as ModeGate, L as CASHU_MINT_SOURCE, M as isRecoveryPhrase, N as normalizePhrase, P as lightningPaying, Q as setAwayWallets, R as cashuMint, S as WALLET_TYPES, T as removeStored, U as iceServerProblem, V as breezDatabasesFor, W as iceServerSetting, X as refuseAway, Y as awayFrom, Z as requireTurn, _ as crossNetwork, a as storedGroupFiles, b as walletInstances, c as receivedPairedReply, d as paymentAlias, f as paymentWireId, g as createTiming, h as createFailure, i as groupOfFile, j as cardsKey, k as CASHU_CARD, l as replyRef, m as assertConfirmedReal, n as groupFileId, o as groupReply, p as WALLET_NAMES, q as WrongNetworkError, r as groupFileText, s as pairedWireReply, t as GroupFileDesk, u as replyTo, v as paymentNetwork, w as readStored$1, y as paymentNetworksOf, z as breezDatabase } from "./groupFiles-uxa0U9_n.js";
-import { i as fedimintDatabase, n as createIrohWebEndpoint, o as loadFedimintSdk, r as irohRelayProblem, t as DEFAULT_IROH_RELAYS } from "./irohWeb-z5QDDWa-.js";
+import { t as nwc } from "./nwcProvider-BKNFdH9v.js";
+import { a as clearProfileStores, c as errorLine, d as openDb, f as profileOpenFailure, h as wrap, i as STORES$1, l as fileStore, m as transact, n as APP_STORAGE_SCOPE_INDEX, o as databaseName, p as store, r as CARD_INDEX, s as deleteDatabase, t as APP_STORAGE_CHAT_INDEX, u as newestWalletTx } from "./idb-CMVgtn2k.js";
+import { a as sealSeed, i as newDeviceKey, o as unsealSeed, r as intentRepository } from "./networkReason-B91upMCb.js";
+import { $ as setSingleWriterGate, A as LightningCards, B as breezDatabaseInUse, C as FileAppender, D as streamStored, E as storedSize, F as ProviderSources, G as ModeChanged, H as dropBreezDatabase, I as sourceKey, J as networkLabel, K as ModeGate, L as CASHU_MINT_SOURCE, M as isRecoveryPhrase, N as normalizePhrase, P as lightningPaying, Q as setAwayWallets, R as cashuMint, S as WALLET_TYPES, T as removeStored, U as iceServerProblem, V as breezDatabasesFor, W as iceServerSetting, X as refuseAway, Y as awayFrom, Z as requireTurn, _ as crossNetwork, a as storedGroupFiles, b as walletInstances, c as receivedPairedReply, d as paymentAlias, f as paymentWireId, g as createTiming, h as createFailure, i as groupOfFile, j as cardsKey, k as CASHU_CARD, l as replyRef, m as assertConfirmedReal, n as groupFileId, o as groupReply, p as WALLET_NAMES, q as WrongNetworkError, r as groupFileText, s as pairedWireReply, t as GroupFileDesk, u as replyTo, v as paymentNetwork, w as readStored$1, y as paymentNetworksOf, z as breezDatabase } from "./groupFiles-sIdGq4AV.js";
+import { i as fedimintDatabase, n as createIrohWebEndpoint, o as loadFedimintSdk, r as irohRelayProblem, t as DEFAULT_IROH_RELAYS } from "./irohWeb-DHCxSvHF.js";
 import { c as isTestMint, d as paysItsOwnInvoices, l as isWorthlessMint, n as DEFAULT_MINTS, o as fakesLightning, r as TEST_MINT, t as BITCOIN_INVOICE_ON_TESTNET, u as mintNetwork } from "./mints-BrlY773j.js";
-import { _ as reserveAdapterIds, b as testBuild, f as setOwnDidSource, g as registeredOnchainProviders, h as registeredLightningProviders, l as chosenResolver, n as resolveAtprotoDid, p as onAdaptersChanged, t as assertPublicServer, v as boundedIdentityFetch, y as verifyIdentity } from "./resolve-CPTAnu-9.js";
-import { c as fileSpace, f as FILE_BYTES_STEP, o as fileBytes, r as blobDigest, s as fileBytesOf, u as removeFileBytes } from "./fileBytes-Di7VZtmU.js";
-import { n as MAX_BACKUP_BYTES, t as BACKUP_MEDIA_TYPE } from "./envelope-DW8TWKPD.js";
+import { _ as reserveAdapterIds, b as testBuild, f as setOwnDidSource, g as registeredOnchainProviders, h as registeredLightningProviders, l as chosenResolver, n as resolveAtprotoDid, p as onAdaptersChanged, t as assertPublicServer, v as boundedIdentityFetch, y as verifyIdentity } from "./resolve-B63_uSu7.js";
+import { c as fileSpace, f as FILE_BYTES_STEP, o as fileBytes, r as blobDigest, s as fileBytesOf, u as removeFileBytes } from "./fileBytes-B-fqGdEd.js";
+import { n as MAX_BACKUP_BYTES, t as BACKUP_MEDIA_TYPE } from "./envelope-C7vnmsJN.js";
 import { t as hyperdhtRelayProblem } from "./hyperdhtRelay-BT_wRxab.js";
 import { sha256 } from "@noble/hashes/sha2.js";
 import { hkdf } from "@noble/hashes/hkdf.js";
 import { base64, base64url, base64urlnopad, bech32, hex } from "@scure/base";
-import { bytesToHex, concatBytes, hexToBytes, utf8ToBytes } from "@noble/hashes/utils.js";
 import { chacha20poly1305 } from "@noble/ciphers/chacha.js";
+import { bytesToHex, concatBytes, hexToBytes, utf8ToBytes } from "@noble/hashes/utils.js";
 import { secp256k1 } from "@noble/curves/secp256k1.js";
 import { verifyEvent } from "nostr-tools/pure";
 import { generateMnemonic, mnemonicToSeedSync, validateMnemonic } from "@scure/bip39";
 import { wordlist } from "@scure/bip39/wordlists/english.js";
-import { Amount, MeltChangeError, OutputData, Wallet, decodePaymentRequest, deserializeSwapPreview, getEncodedToken, getTokenMetadata, isMintOperationError, serializeSwapPreview } from "@cashu/cashu-ts";
 import { decode, noteEncode, npubEncode } from "nostr-tools/nip19";
 /** Evidence older than this says nothing about the clock now. */
 var CLOCK_EVIDENCE_MS = 18e5;
@@ -199,7 +198,7 @@ function viewNews(before, after) {
 //#endregion
 //#region ../browser/src/engine/paymentAdapters/usdtWallet.ts
 /** The Ethereum libraries, a large part of the app: loaded once a USDT wallet is made, opened or restored, not with the engine. */
-var loadUsdt = () => import("./usdt-BY5OIIvG.js");
+var loadUsdt = () => import("./usdt-B7JWDhQV.js");
 /** Every new profile starts with this wallet: an address to receive on, nothing to set up. */
 var DEFAULT_USDT = {
 	network: "ethereum",
@@ -648,7 +647,7 @@ async function restoreArkDatabase(walletId, snapshot) {
 //#endregion
 //#region ../browser/src/engine/paymentAdapters/arkWallet.ts
 /** The Ark SDK, a large part of the app: loaded once an Ark wallet is made, opened or restored, not with the engine. */
-var loadArkade = () => import("./arkade-Cyf5MGxG.js");
+var loadArkade = () => import("./arkade-CP4HvKaa.js");
 /** How long a Testnet wallet about to make way for another waits for its server to say what it holds. */
 var RETIRE_READ_MS = 1e4;
 /** Every new profile starts with this wallet: nothing to set up before receiving. */
@@ -3556,7 +3555,7 @@ 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);
+			if (persist && (await import("@cashu/cashu-ts")).isMintOperationError(error) && await this.wallet.reviewedCashuSpentElsewhere(prepared).catch(() => false)) return this.spentElsewhere(prepared, persist);
 			throw error;
 		}
 		await persist?.();
@@ -6703,7 +6702,7 @@ var registry;
 var loading$1;
 var listeners = /* @__PURE__ */ new Set();
 function loadIdentityProviders() {
-	return loading$1 ??= import("./registry-CxsDR3c6.js").then((m) => {
+	return loading$1 ??= import("./registry-CHPd_hf7.js").then((m) => {
 		registry = m;
 		for (const listener of listeners) listener();
 		return m;
@@ -7132,16 +7131,176 @@ var IdentityProofs = class {
 	}
 };
 //#endregion
+//#region ../browser/src/engine/x401.ts
+var X401_KEY = "x401Credentials";
+var MAX_CREDENTIALS = 32;
+/** Keys waiting for an issuer: the oldest goes when one more is made. */
+var MAX_WAITING_KEYS = 8;
+var ASK_FOR_A_NEW_KEY = "ask the issuer to bind it to a key from x401 key new";
+var LABEL_CHARS = 80;
+var newId$1 = () => toBase64Url(crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(12)));
+/** The paths of an object's members, nested objects' own members included. */
+function paths(value, at = []) {
+	return Object.entries(value).flatMap(([key, item]) => {
+		const path = [...at, key];
+		return typeof item === "object" && item !== null && !Array.isArray(item) ? [path, ...paths(item, path)] : [path];
+	});
+}
+/** The record's retired keys with `more` after them: the latest `MAX_RETIRED_KEYS`. */
+var retire = (stored, more) => [...stored.retired ?? [], ...more].slice(-32);
+/** Why a credential's key is not one waiting for it: what became of it, when this profile made it. */
+function notWaiting(stored, holder) {
+	const held = stored.credentials.find((c) => sameX401HolderJwk(c.holderKey.jwk, holder));
+	if (held) return `This credential's key already holds credential ${held.id} (${held.label}): a key takes one credential`;
+	const retired = [...stored.retired ?? []].reverse().find((r) => sameX401HolderJwk(r.jwk, holder));
+	if (retired?.credential) return `This credential's key went with credential ${retired.credential} when it was removed`;
+	if (retired) return `This credential's key was dropped: a profile keeps the ${MAX_WAITING_KEYS} newest keys waiting for a credential`;
+	return "This credential is bound to a key this profile did not make";
+}
+/**
+* x401 credentials (WISP 3xx), engine side: the profile's holder keys and the credentials issuers bound to them, in
+* the settings store beside the identity proofs. Read from the store on each call: nothing of it stays in memory.
+* Nothing here is shared with a contact, and no presentation is made here yet.
+*/
+var X401Credentials = class {
+	/** Changes one after another: each reads the record and writes it back, and two at once would lose one. */
+	queue = Promise.resolve();
+	serial(change) {
+		const next = this.queue.then(change, change);
+		this.queue = next.catch(() => {});
+		return next;
+	}
+	async load() {
+		return await wrap((await store(STORES$1.settings, "readonly")).get("x401Credentials")) ?? {
+			keys: [],
+			credentials: []
+		};
+	}
+	async save(value) {
+		await transact([STORES$1.settings], (stores) => {
+			stores[STORES$1.settings].put(value, X401_KEY);
+		});
+	}
+	/**
+	* A fresh P-256 holder key, kept until a credential bound to it is added. Its public JWK goes to the issuer. A profile
+	* keeps the 8 newest keys waiting: past them, the oldest is dropped, and `dropped` names it.
+	*/
+	async newKey() {
+		const { secret, jwk } = newX401HolderKey();
+		const deviceKey = newDeviceKey();
+		const key = {
+			id: newId$1(),
+			jwk,
+			secret: {
+				sealed: await sealSeed(toBase64Url(secret), deviceKey),
+				deviceKey
+			},
+			createdAt: Date.now()
+		};
+		secret.fill(0);
+		return this.serial(async () => {
+			const stored = await this.load();
+			const keys = [...stored.keys, key];
+			const dropped = keys.slice(0, -8);
+			await this.save({
+				...stored,
+				keys: keys.slice(-8),
+				retired: retire(stored, dropped.map((k) => ({ jwk: k.jwk })))
+			});
+			return {
+				id: key.id,
+				jwk,
+				...dropped.length ? { dropped: dropped[0].id } : {}
+			};
+		});
+	}
+	/**
+	* Adds an issued credential bound to one of the keys `newKey` made. Refused: a credential that does not read, one
+	* that has expired, one bound to another key, one already kept, a label past `LABEL_CHARS` (it was cut without a
+	* word). A label is one line: its line breaks and tabs read as one space, as a group's name.
+	*/
+	add({ credential, label: given }) {
+		const label = given?.replace(/\s+/g, " ").trim();
+		if (label && ([...label].length > LABEL_CHARS || /\p{Cc}/u.test(label))) return Promise.reject(/* @__PURE__ */ new Error(`A credential's label is up to ${LABEL_CHARS} characters on one line`));
+		const read = readX401SdJwtVc(credential);
+		if (!read.ok) return Promise.reject(/* @__PURE__ */ new Error(`Not an SD-JWT VC Ghostly can keep: ${read.reason}`));
+		const vc = read.value;
+		if (vc.expiresAt !== void 0 && vc.expiresAt * 1e3 <= Date.now()) return Promise.reject(/* @__PURE__ */ new Error(`This credential expired on ${(/* @__PURE__ */ new Date(vc.expiresAt * 1e3)).toISOString()}`));
+		return this.serial(() => this.keep(credential.trim(), vc, label));
+	}
+	async keep(credential, vc, label) {
+		const stored = await this.load();
+		if (stored.credentials.some((c) => c.credential === credential)) throw new Error("This credential is kept already");
+		const holderKey = stored.keys.find((k) => sameX401HolderJwk(k.jwk, vc.holder));
+		if (!holderKey) throw new Error(`${notWaiting(stored, vc.holder)}: ${ASK_FOR_A_NEW_KEY}`);
+		if (stored.credentials.length >= MAX_CREDENTIALS) throw new Error(`A profile keeps at most ${MAX_CREDENTIALS} credentials: remove one first`);
+		const kept = {
+			id: newId$1(),
+			label: label || vc.type.slice(0, LABEL_CHARS),
+			format: vc.format,
+			credential,
+			type: vc.type,
+			issuer: vc.issuer,
+			holderKey,
+			addedAt: Date.now(),
+			...vc.expiresAt !== void 0 ? { expiresAt: vc.expiresAt * 1e3 } : {}
+		};
+		await this.save({
+			...stored,
+			keys: stored.keys.filter((k) => k !== holderKey),
+			credentials: [...stored.credentials, kept]
+		});
+		return this.viewOf(kept, false);
+	}
+	async list({ values = false } = {}) {
+		return (await this.load()).credentials.map((c) => this.viewOf(c, values));
+	}
+	/** Removes a credential and its holder key. False when the profile has no credential with that id. */
+	remove({ id }) {
+		return this.serial(async () => {
+			const stored = await this.load();
+			const gone = stored.credentials.find((c) => c.id === id);
+			if (!gone) return false;
+			await this.save({
+				...stored,
+				credentials: stored.credentials.filter((c) => c !== gone),
+				retired: retire(stored, [{
+					jwk: gone.holderKey.jwk,
+					credential: id
+				}])
+			});
+			return true;
+		});
+	}
+	viewOf(c, values) {
+		const read = readX401SdJwtVc(c.credential);
+		const claims = read.ok ? read.value.claims : {};
+		return {
+			id: c.id,
+			label: c.label,
+			format: c.format,
+			type: c.type,
+			issuer: c.issuer,
+			addedAt: c.addedAt,
+			expiresAt: c.expiresAt ?? null,
+			notBefore: read.ok && read.value.notBefore !== void 0 ? read.value.notBefore * 1e3 : null,
+			claims: paths(claims),
+			disclosable: read.ok ? read.value.disclosable : [],
+			...values ? { values: claims } : {}
+		};
+	}
+};
+//#endregion
 //#region ../browser/src/engine/did.ts
 var KEY$1 = "profileDid";
 /** Mainline keeps a mutable item about two hours: the same packet goes out again every hour. */
 var DID_REPUBLISH_MS = 36e5;
 /** After start, once the chats had their first go at the relays. */
-var FIRST_PUBLISH_MS = 15e3;
+var FIRST_PUBLISH_MS$1 = 15e3;
 /** A few switches flipped in a row make one publish. */
 var CHANGE_DELAY_MS = 2e3;
 /** A failed publish is tried again this much later (not before the hourly one otherwise). */
-var RETRY_MS$1 = 3e5;
+var RETRY_MS$2 = 3e5;
 /** Relay payload header: signature and sequence number, before the DNS packet. */
 var HEADER = 72;
 var ProfileDid = class {
@@ -7179,7 +7338,7 @@ var ProfileDid = class {
 	}
 	start() {
 		this.running = true;
-		this.schedule(FIRST_PUBLISH_MS);
+		this.schedule(FIRST_PUBLISH_MS$1);
 	}
 	stop() {
 		this.running = false;
@@ -7265,7 +7424,7 @@ var ProfileDid = class {
 		this.timer = setTimeout(() => {
 			this.timer = null;
 			this.publishNow().finally(() => {
-				if (this.running && !this.timer) this.schedule(this.error ? RETRY_MS$1 : DID_REPUBLISH_MS);
+				if (this.running && !this.timer) this.schedule(this.error ? RETRY_MS$2 : DID_REPUBLISH_MS);
 			});
 		}, ms);
 	}
@@ -7346,6 +7505,558 @@ var ProfileDid = class {
 		this.stored = next;
 	}
 };
+//#endregion
+//#region ../browser/src/engine/contactLinks.ts
+var CONTACT_LINKS_KEY = "contactLinks";
+/** Mainline keeps a mutable item about two hours: the link record goes out again every hour. */
+var LINK_REPUBLISH_MS = 36e5;
+var OFF_FOR_MS = 2592e6;
+var FIRST_PUBLISH_MS = 15e3;
+var RETRY_MS$1 = 3e5;
+/** How often the knock slots are read: every five minutes, and every 15 s for ten minutes after the link or Requests was shown. */
+var POLL_MS = 3e5;
+var POLL_SHOWN_MS = 15e3;
+var SHOWN_FOR_MS = 6e5;
+var ContactLinks = class {
+	host;
+	stored = { retired: [] };
+	error;
+	timer = null;
+	running = false;
+	inFlight = null;
+	again = false;
+	writes = Promise.resolve();
+	pollTimer = null;
+	shownAt = -Infinity;
+	/** Making, turning off, taking and settling requests run one at a time: each reads and writes the whole record. */
+	queue = Promise.resolve();
+	constructor(host) {
+		this.host = host;
+	}
+	async load() {
+		const found = await wrap((await store(STORES$1.settings, "readonly")).get(CONTACT_LINKS_KEY));
+		this.stored = found ?? { retired: [] };
+	}
+	start() {
+		this.running = true;
+		this.schedule(FIRST_PUBLISH_MS);
+		this.schedulePoll(FIRST_PUBLISH_MS);
+	}
+	stop() {
+		this.running = false;
+		if (this.timer) clearTimeout(this.timer);
+		this.timer = null;
+		if (this.pollTimer) clearTimeout(this.pollTimer);
+		this.pollTimer = null;
+	}
+	/**
+	* The link was shown or copied, or Requests opened: people open a link in the minutes after it is shared, and the
+	* owner looking at Requests wants what came. Look now, and more often for ten minutes.
+	*/
+	shown() {
+		this.shownAt = Date.now();
+		this.schedulePoll(0);
+	}
+	/** Whether a link key is one of this profile's, current or turned off. */
+	owns(linkKeyZ32) {
+		return this.stored.current?.linkKeyZ32 === linkKeyZ32 || this.stored.retired.some((link) => link.linkKeyZ32 === linkKeyZ32);
+	}
+	/** The requests waiting, newest first. */
+	requests() {
+		return [...this.stored.current?.requests ?? []].reverse().map((r) => ({
+			id: r.key,
+			name: r.name,
+			text: r.text,
+			receivedAt: r.receivedAt,
+			expires: r.expires
+		}));
+	}
+	/**
+	* Accept: the owner joins the invite the request carries, and the chat starts as any chat does. The request leaves
+	* Requests and its asker key is never read again on this link.
+	*/
+	accept(id) {
+		return this.serial(async () => {
+			const request = this.stored.current?.requests?.find((r) => r.key === id);
+			if (!request) throw new Error("This request is no longer waiting");
+			if (request.expires <= Date.now()) throw new Error("This request expired");
+			const linkId = await this.host.accept(request);
+			await this.settle(id);
+			return { linkId };
+		});
+	}
+	/** Decline: nothing is said back. The request's name and text are deleted, and its asker key is never read again. */
+	decline(id) {
+		return this.serial(() => this.settle(id));
+	}
+	/** Reads the knock slots once and takes what is new into Requests. */
+	poll() {
+		return this.serial(() => this.take());
+	}
+	/** Undefined while the profile has no link. */
+	view() {
+		const current = this.stored.current;
+		if (!current) return void 0;
+		const code = encodeContactLink(current.linkKeyZ32);
+		return {
+			code,
+			link: inviteLink(code),
+			createdAt: current.createdAt,
+			state: current.inbox.state === "busy" ? "busy" : "open",
+			waiting: current.inbox.waiting.length,
+			missed: current.inbox.missed.length,
+			...current.published ? { publishedAt: current.published } : {},
+			...this.error ? { error: this.error } : {}
+		};
+	}
+	/** Makes the profile's link, turning the one before off: one link per profile at a time. Requests keeps what waits. */
+	create() {
+		return this.serial(() => this.make());
+	}
+	async make() {
+		const made = createContactLink();
+		const deviceKey = newDeviceKey();
+		const now = Date.now();
+		const retired = this.retire(now);
+		const waiting = this.stored.current?.inbox.waiting.filter((w) => w.expires > now) ?? [];
+		const requests = this.stored.current?.requests?.filter((r) => waiting.some((w) => w.key === r.key)) ?? [];
+		const inbox = {
+			...newInbox(now),
+			waiting,
+			state: waiting.length >= 32 ? "busy" : "open"
+		};
+		await this.save({
+			current: {
+				seed: {
+					sealed: await sealSeed(made.seedB64, deviceKey),
+					deviceKey
+				},
+				linkKeyZ32: made.linkKeyZ32,
+				createdAt: now,
+				inbox,
+				...requests.length ? { requests } : {}
+			},
+			retired
+		});
+		this.host.emit();
+		await this.publishNow();
+		return this.view();
+	}
+	/** Turns the link off, for good: requesters who open it are told so. */
+	turnOff() {
+		return this.serial(() => this.off());
+	}
+	async off() {
+		if (!this.stored.current) return;
+		await this.save({ retired: this.retire(Date.now()) });
+		this.host.emit();
+		await this.publishNow();
+	}
+	/** "Clear all data": the link says `off` once, now, and nothing is kept. */
+	async withdraw() {
+		this.stop();
+		const links = [...this.stored.current ? [this.stored.current] : [], ...this.stored.retired];
+		await Promise.allSettled(links.map(async (link) => this.host.publish(await this.identity(link), linkRecords(inboxRecord(turnOff(newInbox(Date.now())), Date.now())))));
+	}
+	/** Publishes what is due now: the current link's record, and `off` for each retired link not said today. */
+	async publishNow() {
+		if (this.inFlight) {
+			this.again = true;
+			return this.inFlight;
+		}
+		this.inFlight = this.publish().finally(() => {
+			this.inFlight = null;
+		});
+		await this.inFlight;
+		if (this.again) {
+			this.again = false;
+			await this.publishNow();
+		}
+	}
+	serial(work) {
+		const run = this.queue.then(work, work);
+		this.queue = run.catch(() => {});
+		return run;
+	}
+	schedulePoll(ms) {
+		if (!this.running) return;
+		if (this.pollTimer) clearTimeout(this.pollTimer);
+		this.pollTimer = setTimeout(() => {
+			this.pollTimer = null;
+			this.poll().catch(() => {}).finally(() => {
+				if (!this.running || this.pollTimer) return;
+				const shown = Date.now() - this.shownAt < SHOWN_FOR_MS;
+				this.schedulePoll(shown ? POLL_SHOWN_MS : POLL_MS);
+			});
+		}, ms);
+	}
+	async take() {
+		const current = this.stored.current;
+		if (!current || !this.host.online()) return;
+		const now = Date.now();
+		const linkKey = current.linkKeyZ32;
+		const slots = await Promise.all(Array.from({ length: 4 }, (_, i) => this.host.resolve(knockSlotIdentity(linkKey, i).pubKeyZ32).catch(() => null)));
+		let inbox = current.inbox;
+		for (const key of endedRequests(inbox, now)) inbox = settleRequest(inbox, key, "ended");
+		const plan = planKnocks(linkKey, inbox, slots.flatMap((records) => records ? readKnockSlot(linkKey, records) : []), now);
+		inbox = plan.inbox;
+		const taken = [];
+		if (plan.read.length) {
+			const { seedB64 } = await this.identity(current);
+			for (const key of plan.read) {
+				const records = await this.host.resolve(key).catch(() => null);
+				const request = records ? openRequest(seedB64, key, records, now) : null;
+				if (!request || this.host.ownInvite(request.invite)) continue;
+				inbox = takeRequest(linkKey, inbox, key, request.expires, now);
+				taken.push({
+					...request,
+					key,
+					receivedAt: now
+				});
+			}
+		}
+		const latest = this.stored.current;
+		if (!latest || latest.linkKeyZ32 !== linkKey) return;
+		const requests = [...current.requests ?? [], ...taken].filter((r) => inbox.waiting.some((w) => w.key === r.key));
+		const changed = plan.publish || taken.length > 0 || inbox.state !== current.inbox.state || inbox.bits !== current.inbox.bits;
+		await this.save({
+			...this.stored,
+			current: {
+				...latest,
+				inbox,
+				requests
+			}
+		});
+		this.host.emit();
+		if (changed) await this.publishNow();
+	}
+	async settle(key) {
+		const current = this.stored.current;
+		if (!current?.requests?.some((r) => r.key === key)) return;
+		const inbox = clearMissed(settleRequest(current.inbox, key));
+		await this.save({
+			...this.stored,
+			current: {
+				...current,
+				inbox,
+				requests: current.requests.filter((r) => r.key !== key)
+			}
+		});
+		this.host.emit();
+		if (inbox.state !== current.inbox.state) await this.publishNow();
+	}
+	retire(now) {
+		const kept = this.stored.retired.filter((link) => now - link.offAt < OFF_FOR_MS);
+		const current = this.stored.current;
+		return current ? [...kept, {
+			seed: current.seed,
+			linkKeyZ32: current.linkKeyZ32,
+			createdAt: current.createdAt,
+			offAt: now
+		}] : kept;
+	}
+	schedule(ms) {
+		if (!this.running) return;
+		if (this.timer) clearTimeout(this.timer);
+		this.timer = setTimeout(() => {
+			this.timer = null;
+			this.publishNow().finally(() => {
+				if (this.running && !this.timer) this.schedule(this.error ? RETRY_MS$1 : LINK_REPUBLISH_MS);
+			});
+		}, ms);
+	}
+	async publish() {
+		if (!this.host.online()) return;
+		const now = Date.now();
+		const { current, retired } = this.stored;
+		let published = false;
+		const said = /* @__PURE__ */ new Set();
+		this.error = void 0;
+		if (current) try {
+			await this.host.publish(await this.identity(current), linkRecords(inboxRecord(current.inbox, now)));
+			published = true;
+		} catch (error) {
+			this.error = error instanceof Error ? error.message : String(error);
+		}
+		for (const link of retired) {
+			if (now - link.offAt >= 2592e6 || link.said !== void 0 && now - link.said < 864e5) continue;
+			try {
+				await this.host.publish(await this.identity(link), linkRecords(inboxRecord(turnOff(newInbox(now)), now)));
+				said.add(link.linkKeyZ32);
+			} catch {}
+		}
+		const latest = this.stored;
+		await this.save({
+			...latest.current ? { current: published && latest.current.linkKeyZ32 === current?.linkKeyZ32 ? {
+				...latest.current,
+				published: now
+			} : latest.current } : {},
+			retired: latest.retired.filter((link) => now - link.offAt < OFF_FOR_MS).map((link) => said.has(link.linkKeyZ32) ? {
+				...link,
+				said: now
+			} : link)
+		});
+		this.host.emit();
+	}
+	async identity(link) {
+		return identityFromSeedB64(await unsealSeed(link.seed.sealed, link.seed.deviceKey));
+	}
+	/**
+	* The record is the one in memory from now on, and the writes go to the database in the order they were made: a
+	* publish that ends while a request is being taken can never put back the record from before it.
+	*/
+	save(next) {
+		this.stored = next;
+		const write = this.writes.then(async () => {
+			await wrap((await store(STORES$1.settings, "readwrite")).put(next, CONTACT_LINKS_KEY));
+		});
+		this.writes = write.catch(() => {});
+		return write;
+	}
+};
+//#endregion
+//#region ../browser/src/engine/contactAsks.ts
+var CONTACT_ASKS_KEY = "contactAsks";
+/** How often a request not yet seen is looked after: every 30 s for ten minutes, then every ten minutes. */
+var ASK_FAST_MS = 3e4;
+var ASK_SLOW_MS = 6e5;
+/** After a knock, its slot is read again this much later, twice at most: another requester may have written at once. */
+var KNOCK_CHECK_MS = 1e3;
+var SLACK_MS = 5e3;
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var ContactAsks = class {
+	host;
+	asks = [];
+	timer = null;
+	running = false;
+	queue = Promise.resolve();
+	constructor(host) {
+		this.host = host;
+	}
+	async load() {
+		this.asks = await wrap((await store(STORES$1.settings, "readonly")).get("contactAsks")) ?? [];
+	}
+	start() {
+		this.running = true;
+		this.schedule(ASK_FAST_MS);
+	}
+	stop() {
+		this.running = false;
+		if (this.timer) clearTimeout(this.timer);
+		this.timer = null;
+	}
+	views() {
+		return this.asks.filter((a) => a.chatId && a.state).map((a) => ({
+			chatId: a.chatId,
+			state: a.state,
+			expires: a.expires
+		}));
+	}
+	/**
+	* Sends a request through a contact link. Refused, with the words the person reads, for a code that is not a contact
+	* link, the profile's own link, a link turned off or busy, a request already waiting there, or a name or text that
+	* breaks a bound. Nothing is made before every check passed.
+	*/
+	ask(params) {
+		return this.serial(() => this.send(params));
+	}
+	/**
+	* The chat a request made was deleted: the request is taken back. Nothing more goes out for it, its record under the
+	* asker key is replaced by an empty one so an owner who has not read it yet finds nothing, and asking again through
+	* the link is open. The asker key stays, one per profile and link. An owner who already took it keeps it until it ends.
+	*/
+	forgetChat(chatId) {
+		return this.serial(async () => {
+			const ask = this.asks.find((a) => a.chatId === chatId);
+			if (!ask) return;
+			const out = ask.state === "sending" || ask.state === "knocking" || ask.state === "seen";
+			await this.put({
+				link: ask.link,
+				seed: ask.seed,
+				key: ask.key
+			});
+			this.host.emit();
+			if (!out || !this.host.online()) return;
+			try {
+				await this.host.publish(await this.identity(ask), []);
+			} catch {}
+		});
+	}
+	/** Looks after every request not yet seen once (the timer does this at its pace). */
+	tick() {
+		return this.serial(() => this.look());
+	}
+	async send({ code, name, text, label }) {
+		const reading = readContactLink(code);
+		if (!reading.ok) throw new Error(reading.reason === "chat" ? "This is a chat invite: open it in Join." : "This is not a Ghostly contact link.");
+		const link = reading.linkKeyZ32;
+		if (this.host.ownLink(link)) throw new Error("This is your contact link.");
+		const now = Date.now();
+		const known = this.asks.find((a) => a.link === link);
+		if (known?.state && known.state !== "ended" && known.state !== "off" && (known.expires ?? 0) > now) throw new Error("You already sent a request through this link.");
+		const record = readLinkRecord(await this.host.resolve(link) ?? []);
+		if (record?.state === "off") throw new Error("This contact link was turned off.");
+		if (record?.state === "busy") throw new Error("They are not taking requests right now. Try again later.");
+		const asker = known ? await this.identity(known) : createIdentity();
+		const request = (invite) => ({
+			invite,
+			name: name.trim(),
+			text: text.trim(),
+			issued: now,
+			expires: now + REQUEST_LIFETIME_MS
+		});
+		try {
+			requestRecords(asker.seedB64, link, request(createChatInvite().inviteCode));
+		} catch (error) {
+			if (!(error instanceof ContactRequestError)) throw error;
+			throw new Error(error.problem === "name" ? "Write a name of up to 48 characters." : error.problem === "too-long" ? "Shorten the message." : "Write a message of up to 200 bytes.");
+		}
+		const chat = await this.host.createChat({
+			...label?.trim() ? { label: label.trim() } : {},
+			text: text.trim()
+		});
+		const sent = request(chat.inviteCode);
+		const ask = {
+			link,
+			key: asker.pubKeyZ32,
+			seed: known?.seed ?? await this.seal(asker),
+			chatId: chat.linkId,
+			invite: chat.inviteCode,
+			name: sent.name,
+			text: sent.text,
+			issued: now,
+			expires: sent.expires,
+			state: "sending"
+		};
+		await this.put(ask);
+		this.tick().catch(() => {});
+		this.schedule(ASK_FAST_MS);
+		return { chatId: chat.linkId };
+	}
+	/** Publishes the request when due and knocks when its knock is gone. Never throws: the next look tries again. */
+	async goOut(ask, asker, publish) {
+		const now = Date.now();
+		try {
+			if (publish) {
+				await this.host.publish(asker, requestRecords(asker.seedB64, ask.link, {
+					invite: ask.invite,
+					name: ask.name,
+					text: ask.text,
+					issued: ask.issued,
+					expires: ask.expires
+				}));
+				ask = {
+					...ask,
+					publishedAt: now
+				};
+			}
+			const slot = knockSlotIdentity(ask.link, knockSlotOf(ask.link, ask.key));
+			for (let attempt = 0; attempt < 3; attempt++) {
+				const knocks = readKnockSlot(ask.link, await this.host.resolve(slot.pubKeyZ32) ?? []);
+				const stamp = ask.stamp;
+				if (knocks.some((k) => k.key === ask.key && k.day === stamp.day && k.stamp === stamp.stamp)) break;
+				if (attempt === 2) break;
+				await this.host.publish(slot, knockSlotRecords(ask.link, mergeContactKnocks(knocks, {
+					key: ask.key,
+					day: stamp.day,
+					stamp: stamp.stamp
+				}, now)));
+				await sleep(KNOCK_CHECK_MS);
+			}
+			ask = {
+				...ask,
+				state: ask.state === "sending" ? "knocking" : ask.state,
+				lookedAt: now
+			};
+		} catch {
+			ask = {
+				...ask,
+				lookedAt: now
+			};
+		}
+		await this.put(ask);
+		this.host.emit();
+	}
+	async look() {
+		if (!this.host.online()) return;
+		const now = Date.now();
+		for (const ask of this.asks) {
+			if (ask.state !== "sending" && ask.state !== "knocking" && ask.state !== "seen") continue;
+			if (ask.expires <= now) {
+				await this.put({
+					...ask,
+					state: "ended"
+				});
+				this.host.emit();
+				continue;
+			}
+			if (ask.state === "seen") continue;
+			const pace = now - ask.issued < 6e5 ? ASK_FAST_MS : ASK_SLOW_MS;
+			if (ask.lookedAt !== void 0 && now - ask.lookedAt < pace - SLACK_MS) continue;
+			const record = readLinkRecord(await this.host.resolve(ask.link).catch(() => null) ?? []);
+			if (record?.state === "off") {
+				await this.put({
+					...ask,
+					state: "off"
+				});
+				this.host.emit();
+				continue;
+			}
+			if (record?.seen.includes(seenEntry(ask.link, ask.key))) {
+				await this.put({
+					...ask,
+					state: "seen"
+				});
+				this.host.emit();
+				continue;
+			}
+			let next = ask;
+			const day = contactDay(now);
+			const bits = Math.max(record?.bits ?? 18, 18);
+			if (!next.stamp || next.stamp.day < day - 1 || next.stamp.bits < bits) next = {
+				...next,
+				stamp: {
+					day,
+					bits,
+					stamp: await makeStampPaced(ask.link, ask.key, day, bits)
+				}
+			};
+			await this.goOut(next, await this.identity(next), next.publishedAt === void 0 || now - next.publishedAt >= 36e5);
+		}
+	}
+	schedule(ms) {
+		if (!this.running) return;
+		if (this.timer) clearTimeout(this.timer);
+		this.timer = setTimeout(() => {
+			this.timer = null;
+			this.tick().catch(() => {}).finally(() => {
+				if (!this.running || this.timer) return;
+				if (this.asks.some((a) => a.state === "sending" || a.state === "knocking")) this.schedule(ASK_FAST_MS);
+				else if (this.asks.some((a) => a.state === "seen")) this.schedule(ASK_SLOW_MS);
+			});
+		}, ms);
+	}
+	serial(work) {
+		const run = this.queue.then(work, work);
+		this.queue = run.catch(() => {});
+		return run;
+	}
+	async seal(identity) {
+		const deviceKey = newDeviceKey();
+		return {
+			sealed: await sealSeed(identity.seedB64, deviceKey),
+			deviceKey
+		};
+	}
+	async identity(ask) {
+		return identityFromSeedB64(await unsealSeed(ask.seed.sealed, ask.seed.deviceKey));
+	}
+	async put(ask) {
+		const next = [...this.asks.filter((a) => a.link !== ask.link), ask];
+		await wrap((await store(STORES$1.settings, "readwrite")).put(next, CONTACT_ASKS_KEY));
+		this.asks = next;
+	}
+};
 function profileName(value) {
 	if (typeof value !== "string" || value.length > 256) return;
 	return value.replace(/[\u0000-\u001f\u007f-\u009f\u202a-\u202e\u2066-\u2069]/g, "").trim().slice(0, 64) || void 0;
@@ -9883,6 +10594,17 @@ function forwardKind(message) {
 	if (message.file) return "file";
 	return message.text.trim() ? "text" : { refused: "This message cannot be forwarded" };
 }
+/**
+* Why a chat did not get a forward, as its result says it: never "" (a result with an error is a failure, whatever it
+* says). A copy that found no room says so in the words the app knows however the storage put it: IndexedDB's
+* QuotaExceededError (an empty message in Chromium), the OPFS worker's (named so), Desktop's io error (the system's English).
+*/
+function forwardError(error) {
+	const message = (error instanceof Error ? error.message : String(error)).trim();
+	if (/^No space left on device\b/.test(message)) return `Not enough space on this device (${message})`;
+	const name = error?.name;
+	return errorLine(error).trim() || (typeof name === "string" && name ? name : "Error");
+}
 /** How many bytes of a stored file are actually here: all of them once it arrived. */
 async function bytesHere(file) {
 	if (file.blob) return file.blob.size;
@@ -10164,14 +10886,14 @@ var DEFAULT_APP_STORES = [{
 * entry is added with the pin of its bundle in apps/ui/src/assets/apps/built-in.json, which the build reads from the
 * app's own repository (apps/ui/scripts/built-in-apps.mjs); no bundle is kept in this repository.
 *
-* Chess: Ghostly's own publisher key for it (fingerprint odcg w6wj w8dy nqop), version 2.3.0 (`sequence` 4), at the
+* Chess: Ghostly's own publisher key for it (fingerprint odcg w6wj w8dy nqop), version 2.3.1 (`sequence` 5), at the
 * commit of its repository that the official store lists.
 */
 var BUILT_IN_APPS = [{
 	publisher: "odcgw6wjw8dynqop84r47jbjcdqossbgrfiejd367e14hgxmjcho",
 	name: "chess",
-	digest: "EEnFmP0grTkTe_9qgapQsEEZzWB9FcpoimWkHnfecVs",
-	url: "https://cdn.jsdelivr.net/gh/MiguelMedeiros/ghostly-chess@c665ab194478145fd9b9a4777e6c0d1893969649/app.ghostlyapp",
+	digest: "PnrjBRayGNbhfCkjPXmxLpjKYe2_m9Q65_hUPP8BHOc",
+	url: "https://cdn.jsdelivr.net/gh/MiguelMedeiros/ghostly-chess@0cbf1acc8fd7a03848f4e2a68cbec8854767ceaa/app.ghostlyapp",
 	title: "Chess",
 	tagline: "Play chess with a contact, live in your chat"
 }];
@@ -19822,6 +20544,11 @@ var Outbox = class {
 	get sameLink() {
 		return !this.stopped && this.closed === this.began;
 	}
+	/** A check is scheduled for something queued or waiting: one that went out keeps its `waiting` entry (its backoff step), not its timer. */
+	get scheduled() {
+		for (const wait of this.waiting.values()) if (wait.timer) return true;
+		return false;
+	}
 	/** One message as stored now: by its id when the store can, else picked out of the chat's history. */
 	async one(id) {
 		return this.store.get ? this.store.get(id) : (await this.store.read()).find((m) => m.id === id);
@@ -19872,12 +20599,6 @@ var Outbox = class {
 		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;
@@ -19892,11 +20613,20 @@ var Outbox = class {
 			return false;
 		}
 		if (passed) await this.catchUp(passed);
-		if (!this.sameLink) return true;
+		if (!this.sameLink) {
+			if (!this.stopped && !this.waiting.get(message.id)?.timer) this.schedule(message.id);
+			return true;
+		}
 		await this.resender.sendFile(message).catch(() => {});
 		this.forget(message.id);
 		return true;
 	}
+	/**
+	* 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.
+	*/
 	async inOrder(messages) {
 		const passed = [];
 		for (const message of messages) {
@@ -19991,15 +20721,16 @@ var Outbox = class {
 		await this.store.update(id, "delivered");
 		this.clear(id);
 		this.forget(id);
-		if (this.waiting.size) this.flush().catch(() => {});
+		if (this.scheduled) this.flush().catch(() => {});
 	}
 	/**
 	* The chat can carry text again (its link came back, or the DHT path freed up): every queued message goes now,
 	* 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).
+	* (a receipt on the link also ends the DHT's own retries). Bare, it looks only when a check is scheduled: a receipt,
+	* and every read of the contact's DHT mailbox, call it.
 	*/
 	flush({ reopened = false } = {}) {
-		if (this.stopped || !reopened && !this.waiting.size) return Promise.resolve();
+		if (this.stopped || !reopened && !this.scheduled) return Promise.resolve();
 		const opened = reopened ? ++this.opened : void 0;
 		return this.turn(async () => {
 			if (this.stopped) return;
@@ -20007,15 +20738,47 @@ var Outbox = class {
 			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. */
+	/**
+	* A queued message's check came due: the ones written before it that have not gone are looked at first. The checks
+	* of n texts written to an away contact come due a few milliseconds apart, and each read the chat and looked at
+	* every older text again: n²/2 reads at each backoff step. The first look now takes up every check due by the next
+	* few seconds too (`backoffMs[0]`), and what was written before them, and gives each its next one: they come due
+	* together from then on, and the others find theirs taken.
+	*/
 	async check(id) {
 		if (this.stopped) return;
+		if (this.waiting.get(id)?.timer || this.receipts.has(id)) 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;
 		}
-		await this.inOrder(this.due(messages.filter((m) => m.timestamp <= message.timestamp)));
+		const soon = this.now() + this.policy.backoffMs[0], taken = [];
+		let until = message.timestamp;
+		for (const m of messages) {
+			const wait = this.waiting.get(m.id);
+			if (m.id === id || !wait || this.busy.has(m.id) || !(toGo(m) || this.file(m)) || wait.timer && wait.at > soon) continue;
+			if (wait.timer) {
+				clearTimeout(wait.timer);
+				wait.timer = void 0;
+				wait.step++;
+			}
+			taken.push(m.id);
+			if (m.timestamp > until) until = m.timestamp;
+		}
+		await this.inOrder(this.due(messages.filter((m) => m.timestamp <= until)));
+		for (const other of taken) {
+			const wait = this.waiting.get(other);
+			if (!this.stopped && wait && !wait.timer && !this.busy.has(other) && !this.receipts.has(other)) this.schedule(other);
+		}
+	}
+	/**
+	* As read by the look in progress, it still waits: the chat cannot carry it, and it is not due to fail or to be
+	* handed to store-and-forward. Nothing acts on it, so it is not read again.
+	*/
+	waitsOn(message) {
+		const wait = this.waiting.get(message.id);
+		return !!wait && (message.delivery === "queued" || message.delivery === "waiting") && message.via !== "hold" && (message.resendUntil ?? Infinity) > this.now() && !this.resender.ready(message) && !(this.resender.divert && this.now() - wait.since >= this.policy.holdAfterMs);
 	}
 	/**
 	* A queued or waiting message is looked at; one sent and awaiting its receipt goes again now, if the chat can carry
@@ -20023,7 +20786,7 @@ var Outbox = class {
 	*/
 	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 === "queued" || message.delivery === "waiting") return this.attempt(message.id, passed, message);
 		if (message.delivery !== "sent" || !this.receipts.has(message.id)) return true;
 		this.clear(message.id);
 		if (this.resender.ready(message)) {
@@ -20067,10 +20830,15 @@ var Outbox = class {
 	/**
 	* 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.
+	* moment ago, which go first if it can now. `read`: its row as the look in progress read it; while it still waits
+	* (`waitsOn`) it is not read again, else a look at n waiting texts read each of them once more.
 	*/
-	async attempt(id, passed) {
+	async attempt(id, passed, read) {
 		if (this.stopped || this.busy.has(id)) return true;
+		if (read && this.waitsOn(read)) {
+			if (!this.waiting.get(id)?.timer) this.schedule(id);
+			return false;
+		}
 		const message = await this.one(id);
 		if (!message || message.delivery !== "queued" && message.delivery !== "waiting" || message.via === "hold") {
 			this.forget(id);
@@ -20122,10 +20890,12 @@ var Outbox = class {
 	schedule(id) {
 		const wait = this.waiting.get(id) ?? {
 			step: 0,
-			since: this.now()
+			since: this.now(),
+			at: 0
 		};
 		if (wait.timer) clearTimeout(wait.timer);
 		const delay = this.policy.backoffMs[Math.min(wait.step, this.policy.backoffMs.length - 1)];
+		wait.at = this.now() + delay;
 		wait.timer = setTimeout(() => {
 			wait.timer = void 0;
 			wait.step++;
@@ -20194,6 +20964,9 @@ var EditQueue = class {
 	restoredAt = -Infinity;
 	/** The rows known to have an edit on its way, each with when it was last told (`edited`), by `tick`. */
 	known = /* @__PURE__ */ new Map();
+	/** Of the known rows read: each one's wire id, and the DHT floor id of the edit it last sent (`dhtEditId`). A receipt finds its row by them. */
+	wires = /* @__PURE__ */ new Map();
+	dhtIds = /* @__PURE__ */ new Map();
 	tick = 0;
 	/** The chat's history was read for the rows with an edit on its way: `known` has them all, until the next session. */
 	learnt = false;
@@ -20247,40 +21020,57 @@ var EditQueue = class {
 	}
 	/**
 	* My rows with an edit on its way, by time. `all`: the chat's whole history, when it was read for them (no `row` to
-	* read one by, or nothing learnt yet in this session). Otherwise the known rows are read alone, and one that waits
-	* no more is forgotten, unless it was told again while it was read.
+	* read them by, or nothing learnt yet in this session). Otherwise the known rows (`only`: those of them) are read
+	* alone, in one read, and one that waits no more is forgotten, unless it was told again while it was read.
 	*/
-	async pending() {
+	async pending(only) {
 		const waits = (m) => m.sender === "me" && !!m.edit?.pending;
-		const row = this.deps.row;
-		if (!row || !this.learnt) {
+		const read = this.deps.rows;
+		if (!read || !this.learnt) {
 			const all = await this.deps.read(), rows = all.filter(waits);
-			for (const m of rows) if (!this.known.has(m.id)) this.known.set(m.id, this.tick);
+			for (const m of rows) {
+				if (!this.known.has(m.id)) this.known.set(m.id, this.tick);
+				if (m.wireId) this.wires.set(m.id, m.wireId);
+			}
 			this.learnt = true;
 			return {
 				rows,
 				all
 			};
 		}
-		const asOf = this.tick, ids = [...this.known.keys()];
-		const read = await Promise.all(ids.map((id) => row(id)));
+		const asOf = this.tick, ids = only ?? [...this.known.keys()];
 		const rows = [];
-		read.forEach((m, i) => {
-			if (m && waits(m)) rows.push(m);
-			else if ((this.known.get(ids[i]) ?? 0) <= asOf) this.known.delete(ids[i]);
+		(ids.length ? await read(ids) : []).forEach((m, i) => {
+			if (m && waits(m)) {
+				rows.push(m);
+				if (m.wireId) this.wires.set(m.id, m.wireId);
+			} else if ((this.known.get(ids[i]) ?? 0) <= asOf) {
+				this.known.delete(ids[i]);
+				this.wires.delete(ids[i]);
+				this.dhtIds.delete(ids[i]);
+			}
 		});
 		return { rows: rows.sort((a, b) => a.timestamp - b.timestamp) };
 	}
+	/**
+	* The known rows a receipt may be for: the one `matches` finds among those read before, else those not read yet (none:
+	* it names no edit on its way). Undefined: no rows to read them by, or nothing learnt yet, so all of them.
+	*/
+	candidates(ids, matches) {
+		if (!this.deps.rows || !this.learnt) return void 0;
+		for (const [rowId, value] of ids) if (matches(value) && this.known.has(rowId)) return [rowId];
+		return [...this.known.keys()].filter((rowId) => !ids.has(rowId));
+	}
 	/** The contact confirmed edit `seq` of my message with this wire id. */
 	async received(wireId, seq) {
-		const row = (await this.pending()).rows.find((m) => m.wireId === wireId);
+		const row = (await this.pending(this.candidates(this.wires, (id) => id === wireId))).rows.find((m) => m.wireId === wireId);
 		if (!row?.edit?.pending || row.edit.seq > seq) return;
 		this.sent.delete(row.id);
 		await this.deps.settle(row.id, row.edit.seq);
 	}
 	/** The contact confirmed, on the DHT floor, the edit that went there under this id (`dhtEditId`). */
 	async receivedOnDht(id) {
-		const row = (await this.pending()).rows.find((m) => m.wireId && dhtEditId(m.wireId, m.edit.seq) === id);
+		const row = (await this.pending(this.candidates(this.dhtIds, (sent) => sent === id))).rows.find((m) => m.wireId && dhtEditId(m.wireId, m.edit.seq) === id);
 		if (!row) return;
 		this.sent.delete(row.id);
 		await this.deps.settle(row.id, row.edit.seq);
@@ -20291,7 +21081,7 @@ var EditQueue = class {
 		this.timer = void 0;
 	}
 	async run() {
-		if (this.stopped) return;
+		if (this.stopped || !this.deps.ready()) return;
 		const now = this.now();
 		const said = (m) => this.sent.get(m.id)?.seq === m.edit.seq ? 1 : 0;
 		const { rows, all } = await this.pending();
@@ -20347,6 +21137,7 @@ var EditQueue = class {
 				...message.card && { sc: message.card }
 			}, message)) continue;
 			if (edit.restore) this.restoredAt = now;
+			this.dhtIds.set(message.id, dhtEditId(message.wireId, edit.seq));
 			this.sent.set(message.id, {
 				seq: edit.seq,
 				at: now,
@@ -20997,6 +21788,15 @@ var db = {
 		return wrap((await store(STORES$1.messages, "readonly")).get([linkId, id]));
 	},
 	/**
+	* These rows of a chat, in the order asked (undefined where none is), in one transaction: in the CLI's store
+	* (fake-indexeddb) each transaction waiting at once is checked against all the others, so one per row costs the square.
+	*/
+	async getMessagesById(linkId, ids) {
+		if (!ids.length) return [];
+		const messages = await store(STORES$1.messages, "readonly");
+		return Promise.all(ids.map((id) => wrap(messages.get([linkId, id]))));
+	},
+	/**
 	* The newest `limit` messages of a chat before `before`, oldest first, in `getMessages`' order (time, then id), and
 	* whether older ones remain. Reads those rows only: a long chat's first page costs what a short one's does.
 	* `before`: a message's place (the page ends just before it), or a time (`id` left out: the page ends before it).
@@ -21530,6 +22330,12 @@ async function myPin(host, chat, messageId, remove, current, now = Date.now()) {
 * about a catch-up, whose answers end within the three minutes the app waits for the first.
 */
 var AUTHOR_ORDER_WINDOW_MS = 18e4;
+/**
+* While some of a member's messages are still on their way, how long that member's rows wait for the next one before
+* they are placed again anyway: longer than a catch-up takes to ask for its next 32 (`MESH_GAP_AGAIN_MS`, 10 s). Placed
+* at each page, the newest rows moved down again with every older page, up to 84 writes a row for 200 caught up.
+*/
+var AUTHOR_ORDER_SETTLE_MS = 15e3;
 AUTHOR_ORDER_WINDOW_MS / 2;
 /** Whether `a` was written after `b` by the same member: a later epoch, or a higher number in the same one. */
 function after(a, b) {
@@ -21539,10 +22345,12 @@ function after(a, b) {
 * A member's messages in a private group in the order that member wrote them (WISP 400, requirement 10, and WISP 902
 * § Catch-up). A message is placed where it arrives. When one comes of a member whose later messages were placed here
 * moments ago (two catch-up answers raced: the author's own newest 32 and another member's hand-on of the older ones),
-* those later ones are placed again below it, in the order they were written, and the lines that came after them before
-* the older one (another member's, mine) go along below them, in their order: a reply to the newest stays below it. A
-* row only ever moves down, so nobody else's lines change order. While messages of that member are still missing
-* (`missing`), the rows wait for them, so each row moves about once in a whole catch-up.
+* it is stored just above the first of them where the history has room there (`above`): the author's newest stays
+* the last while the older pages come. Where it has none, those later ones are placed again below it, in the order
+* they were written, and the lines that came after them before the older one (another member's, mine) go along below
+* them, in their order: a reply to the newest stays below it. A row only ever moves down, so nobody else's lines change
+* order. While messages of that member are still missing (`missing`), the rows wait for them, so each row moves about
+* once in a whole catch-up.
 */
 var GroupAuthorOrder = class {
 	host;
@@ -21550,6 +22358,7 @@ var GroupAuthorOrder = class {
 	missing;
 	/** Per group: the members' rows followed, in the order they are placed in the history. */
 	rows = /* @__PURE__ */ new Map();
+	came = 0;
 	/** Per group: the members with a row placed above an older one of theirs, since when, and when their last row came. */
 	due = /* @__PURE__ */ new Map();
 	running = /* @__PURE__ */ new Set();
@@ -21558,14 +22367,37 @@ var GroupAuthorOrder = class {
 		this.linkOf = linkOf;
 		this.missing = missing;
 	}
-	/** A member's message was stored in the group's history, new: `at` is when, on the engine's clock. */
-	placed(groupId, row) {
+	/**
+	* The row a member's message about to be stored goes just above: the first placed of those that member wrote after
+	* it, when nobody else's came after that one (a hand-on of everyone's older messages brings them in the order they
+	* were written: the message goes after those). None when nothing they wrote later was placed here, or another's
+	* came since: it goes where it comes.
+	*/
+	above(groupId, row) {
+		const rows = this.rows.get(groupId) ?? [];
+		if (rows.some((r) => r.id === row.id)) return void 0;
+		const at = rows.findIndex((r) => r.sender === row.sender && after(r, row));
+		return at >= 0 && rows.slice(at).every((r) => r.sender === row.sender) ? rows[at].id : void 0;
+	}
+	/**
+	* A member's message was stored in the group's history, new: `at` is when, on the engine's clock. `above`: the row
+	* it was stored just above, as `above` named it; else it went to the end.
+	*/
+	placed(groupId, row, above) {
 		if (!this.host.placeAgain) return;
 		const rows = (this.rows.get(groupId) ?? []).filter((r) => r.at > row.at - AUTHOR_ORDER_WINDOW_MS).slice(-575);
-		rows.push(row);
+		const at = above === void 0 ? -1 : rows.findIndex((r) => r.id === above);
+		const followed = {
+			...row,
+			n: ++this.came
+		};
+		if (at >= 0) rows.splice(at, 0, followed);
+		else rows.push(followed);
 		this.rows.set(groupId, rows);
 		let due = this.due.get(groupId);
-		if (!due?.has(row.sender) && !rows.some((r) => r.sender === row.sender && after(r, row))) return;
+		const first = rows.slice(0, at >= 0 ? at : -1).findIndex((r) => r.sender === row.sender && after(r, row));
+		if (!due?.has(row.sender) && first < 0) return;
+		if (first >= 0) for (const r of rows.slice(first)) r.at = Math.max(r.at, row.at);
 		if (!due) this.due.set(groupId, due = /* @__PURE__ */ new Map());
 		due.set(row.sender, {
 			since: due.get(row.sender)?.since ?? row.at,
@@ -21608,21 +22440,22 @@ var GroupAuthorOrder = class {
 					const newer = mine.filter((r) => !after(from, r)).sort((a, b) => after(a, b) ? 1 : after(b, a) ? -1 : 0);
 					const ids = new Set(newer.map((r) => r.id));
 					const first = rows.findIndex((r) => ids.has(r.id));
-					let end = rows.length;
-					for (let i = first + 1, top = rows[first]; i < rows.length; i++) {
-						if (rows[i].sender !== sender) continue;
-						if (after(top, rows[i])) {
-							end = i;
+					let end = Infinity, top = rows[first];
+					for (const r of rows.filter((r) => r.n > rows[first].n).sort((a, b) => a.n - b.n)) {
+						if (r.sender !== sender) continue;
+						if (after(top, r)) {
+							end = r.n;
 							break;
 						}
-						top = rows[i];
+						top = r;
 					}
-					const followers = rows.slice(first, end).filter((r) => r.sender !== sender);
+					const followers = rows.slice(first).filter((r) => r.sender !== sender && r.n < end);
 					for (const r of followers) ids.add(r.id);
 					const moved = [...newer, ...followers];
 					this.rows.set(groupId, [...rows.filter((r) => !ids.has(r.id)), ...moved.map((r) => ({
 						...r,
-						at: Math.max(r.at, now)
+						at: Math.max(r.at, now),
+						n: ++this.came
 					}))]);
 					await this.host.placeAgain(this.linkOf(groupId), moved.map((r) => r.id)).catch(() => {});
 				}
@@ -21632,8 +22465,8 @@ var GroupAuthorOrder = class {
 		}
 	}
 };
-//#endregion
-//#region ../browser/src/engine/groupLineOrder.ts
+/** How long the lines wait at most while older messages keep coming: one move every so often in a long catch-up. */
+var LINE_ORDER_WAIT_MAX_MS = AUTHOR_ORDER_SETTLE_MS;
 /**
 * The lines of a group's history ("… joined", "… is no longer a member") among the messages of their moment, for a
 * member back from away (WISP 902 § Catch-up). A message sealed under an epoch was written before its author knew of
@@ -21642,30 +22475,39 @@ var GroupAuthorOrder = class {
 * its epoch) and, in a private group, the answers of several members race, so the messages of the epoch before can come
 * after the line. Then the line, and the rows after it written knowing it, are placed again below them, in their order;
 * no clock is read. A row only ever moves down, and only rows placed here in the last few minutes, so a live
-* conversation read long ago never moves. Moves made meanwhile go in one turn: a row moves about once a catch-up page.
+* conversation read long ago never moves. The lines wait for the rest of the older messages (`tick`), and while
+* messages of an epoch before are still on their way (`onTheirWay`) the rows wait for them, as `GroupAuthorOrder`'s do:
+* a row moves about once a catch-up.
 */
 var GroupLineOrder = class {
 	host;
+	onTheirWay;
 	/** Per history: the rows followed, in the order they are placed in it. */
 	rows = /* @__PURE__ */ new Map();
+	/** Per history with rows out of order: since when, and when the last one came. */
+	waiting = /* @__PURE__ */ new Map();
 	due = /* @__PURE__ */ new Set();
 	running = /* @__PURE__ */ new Set();
-	constructor(host) {
+	constructor(host, onTheirWay = () => false) {
 		this.host = host;
+		this.onTheirWay = onTheirWay;
 	}
 	/**
 	* A row is being stored, a line of the history or a message sealed under this epoch, and takes its place now: `at` is
 	* when, on the engine's clock. Call what this returns with whether it was new: a message below a line of a later
-	* epoch takes the line (and the rows after it written knowing it) below it.
+	* epoch takes the line (and the rows after it written knowing it) below it. `above`: the row it is stored just above
+	* (`GroupAuthorOrder.above`); else it goes to the end.
 	*/
-	placing(linkId, row, at) {
+	placing(linkId, row, at, above) {
 		if (!this.host.placeAgain) return () => {};
 		const followed = {
 			...row,
 			at
 		};
 		const rows = (this.rows.get(linkId) ?? []).filter((r) => r.at > at - AUTHOR_ORDER_WINDOW_MS).slice(-575);
-		rows.push(followed);
+		const index = above === void 0 ? -1 : rows.findIndex((r) => r.id === above);
+		if (index >= 0) rows.splice(index, 0, followed);
+		else rows.push(followed);
 		this.rows.set(linkId, rows);
 		return (stored) => {
 			const now = this.rows.get(linkId);
@@ -21673,23 +22515,46 @@ var GroupLineOrder = class {
 				if (now) this.rows.set(linkId, now.filter((r) => r !== followed));
 				return;
 			}
-			if (!followed.line && now?.some((r) => r.line && r.epoch > followed.epoch && now.indexOf(r) < now.indexOf(followed))) this.run(linkId);
+			if (followed.line || !now) return;
+			const line = now.findIndex((r) => r.line && r.epoch > followed.epoch);
+			if (line < 0 || line > now.indexOf(followed)) return;
+			for (const r of now.slice(line)) r.at = Math.max(r.at, at);
+			this.wait(linkId, at);
 		};
 	}
-	/** These rows were placed again below everything (`GroupAuthorOrder`), in this order. */
-	moved(linkId, ids) {
+	/** These rows were placed again below everything (`GroupAuthorOrder`), in this order, at `at` on the engine's clock. */
+	moved(linkId, ids, at) {
 		const rows = this.rows.get(linkId);
 		if (!rows) return;
 		const moved = ids.map((id) => rows.find((r) => r.id === id)).filter((r) => !!r);
 		if (!moved.length) return;
 		this.rows.set(linkId, [...rows.filter((r) => !moved.includes(r)), ...moved]);
-		if (moved.some((r) => !r.line)) this.run(linkId);
+		if (moved.some((r) => !r.line)) this.wait(linkId, at);
+	}
+	/**
+	* Time passed: histories no older message came to for a moment, and nothing more is on its way for, or that waited
+	* long enough, are put in order.
+	*/
+	tick(now) {
+		for (const [linkId, { since, last }] of this.waiting) {
+			if (now - last < 3e3 && now - since < LINE_ORDER_WAIT_MAX_MS) continue;
+			if (now - last < 15e3 && now - since < 9e4 && this.onTheirWay(linkId)) continue;
+			this.waiting.delete(linkId);
+			this.run(linkId);
+		}
 	}
 	/** The group's history is gone (left or forgotten). */
 	forget(linkId) {
 		this.rows.delete(linkId);
+		this.waiting.delete(linkId);
 		this.due.delete(linkId);
 	}
+	wait(linkId, at) {
+		this.waiting.set(linkId, {
+			since: this.waiting.get(linkId)?.since ?? at,
+			last: at
+		});
+	}
 	/** The history's rows put in order; what comes while a move is written goes in the next turn. */
 	run(linkId) {
 		this.due.add(linkId);
@@ -21705,8 +22570,9 @@ var GroupLineOrder = class {
 						if (above < 0) order.push(row);
 						else order.splice(above, 0, row);
 					}
+					const place = new Map(rows.map((r, i) => [r, i]));
 					let from = 0;
-					while (from < rows.length && rows[from] === order[from]) from++;
+					while (from < order.length && (from === 0 || place.get(order[from]) > place.get(order[from - 1]))) from++;
 					if (from === rows.length) continue;
 					const last = rows[rows.length - 1].at;
 					for (const r of order.slice(from)) r.at = Math.max(r.at, last);
@@ -21892,6 +22758,14 @@ var CUT_OFF_STEP_UP_MS = 15e3;
 /** A lobby request this recent is from a member still looking fast for my side of the edge: mine opens expecting it. */
 var LOBBY_EXPECT_MS = 3e4;
 /**
+* A member whose edge was down `memberGoneMs` is dropped by its hub, and its edge closed: its app closed, and is often
+* opened again within minutes, when it dials an edge my side no longer has and asks in my lobby. So my lobby is read at
+* the busy pace this long after, as a 1:1 chat watches a contact that went away (`WATCH_PEER_MS`). Read every half minute,
+* a web member back two minutes after it closed got the lines written meanwhile 30-45 s after it opened, while a 1:1
+* text from the same bot came in seconds (bug hunt 1013-2254, 2026-10-14).
+*/
+var MEMBER_BACK_MS = WATCH_PEER_MS;
+/**
 * A lobby is one record every member asking a hub writes, each reading it and writing it back with its own request: two
 * members writing at once (both cut off by the same leave, in the same second) each write what they read, and the later
 * write drops the earlier request. So a member reads the lobby back this long after its write (plus up to `LOBBY_CHECK_JITTER_MS`, so
@@ -22352,10 +23226,10 @@ var Communities = class {
 		await this.require(groupId).rotate();
 	}
 	async setPicture(groupId, picture) {
-		await this.require(groupId).setPicture(picture);
+		await this.require(groupId).setPicture(picture, this.now());
 	}
 	async rename(groupId, name) {
-		await this.require(groupId).rename(name);
+		await this.require(groupId).rename(name, this.now());
 	}
 	/** A new link (the old one reaches nobody), or none. */
 	async replaceLink(groupId, off = false) {
@@ -22418,6 +23292,7 @@ var Communities = class {
 	/** Everything timed: beacon, hub election, lobbies, knocks, leaves, edges. The engine calls it every second or so. */
 	async tick(now = Date.now()) {
 		this.time = now;
+		this.lineOrder.tick(now);
 		const active = [...this.live.values()].filter((l) => l.session.status === "active");
 		this.sharing = {
 			groups: Math.max(1, active.length),
@@ -22551,7 +23426,7 @@ var Communities = class {
 			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);
 			if (this.hubDropped(groupId, live, others, now)) live.lobbyBusyUntil = Math.max(live.lobbyBusyUntil, now + this.timings.lobbyBusyMs);
-			const lobbyEvery = now < live.lobbyBusyUntil && !busy ? this.timings.lobbyPollMs : this.timings.lobbyIdlePollMs;
+			const lobbyEvery = (now < live.lobbyBusyUntil || now < (live.memberBackUntil ?? 0)) && !busy ? this.timings.lobbyPollMs : this.timings.lobbyIdlePollMs;
 			if (now - live.lastLobbyPoll >= lobbyEvery) {
 				live.lastLobbyPoll = now;
 				await this.pollLobby(groupId, live, now);
@@ -22595,6 +23470,9 @@ var Communities = class {
 			}
 			let kept = live.myHubs.filter((key) => (fresh.has(key) || this.recentHub(live, key)) && !live.hubsAvoided.has(key));
 			kept = kept.slice(0, COMMUNITY_TOPOLOGY.hubsPerMember);
+			if (!kept.length) {
+				for (const key of live.restored.keys()) if (kept.length < COMMUNITY_TOPOLOGY.hubsPerMember && !live.hubsAvoided.has(key) && others.some((h) => h.key === key && h.load < COMMUNITY_TOPOLOGY.hubCapacity)) kept.push(key);
+			}
 			const picked = pickHubs(me, others, now, new Set(live.hubsAvoided.keys()));
 			const bare = ![...edges.values()].some((id) => this.host.linkReady(id, 2));
 			for (const key of picked) if (kept.length < Math.max(1, picked.length) && !kept.includes(key)) {
@@ -22693,7 +23571,11 @@ var Communities = class {
 			const id = edges.get(key);
 			if (this.gone(live, key)) live.members.delete(key);
 			else if (id && this.host.linkReady(id, 2)) live.members.set(key, now);
-			else if (now - since > this.timings.memberGoneMs || live.session.wasRemoved(key)) live.members.delete(key);
+			else if (live.session.wasRemoved(key)) live.members.delete(key);
+			else if (now - since > this.timings.memberGoneMs) {
+				live.members.delete(key);
+				live.memberBackUntil = now + MEMBER_BACK_MS;
+			}
 		}
 		this.shed(groupId, live, now);
 		return live.members.size;
@@ -22746,7 +23628,8 @@ var Communities = class {
 	async readBeacon(groupId, live, now) {
 		live.lastBeaconRead = now;
 		const keys = beaconKeys(live.session.state.rv, groupId);
-		const records = await this.host.resolve(keys.identity.pubKeyZ32, true, this.doorBusy(groupId, live, now)).catch(() => void 0);
+		const back = !live.beaconAt && this.wayBack(groupId, live);
+		const records = await this.host.resolve(keys.identity.pubKeyZ32, !back, !back && this.doorBusy(groupId, live, now), back).catch(() => void 0);
 		if (records === void 0) {
 			live.beaconFailedAt = now;
 			live.beaconAskedAt ||= now;
@@ -22779,9 +23662,10 @@ var Communities = class {
 	async publishBeacon(groupId, live, now, listed) {
 		live.lastBeaconTry = now;
 		const keys = beaconKeys(live.session.state.rv, groupId);
+		const back = live.hub && this.wayBack(groupId, live);
 		let existing = live.beacon, head = live.head;
 		if (live.lastBeaconRead !== now || live.beaconFailedAt === now) {
-			const read = await this.host.resolve(keys.identity.pubKeyZ32, true, live.hub).catch(() => void 0);
+			const read = await this.host.resolve(keys.identity.pubKeyZ32, !back, live.hub && !back, back).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 = live.hubClocks.inMyTime(readBeacon(keys, records), now);
@@ -22794,7 +23678,7 @@ var Communities = class {
 			since: live.hubSince || now
 		} : null, now, (key) => !this.gone(live, key));
 		const newest = newerHead(head, this.newestFrame(live), now);
-		await this.host.publish(keys.identity, beaconRecords(keys, live.hubClocks.asWritten(hubs), newest), true, live.hub);
+		await this.host.publish(keys.identity, beaconRecords(keys, live.hubClocks.asWritten(hubs), newest), !back, live.hub && !back, back);
 		live.beacon = hubs;
 		live.head = newest;
 		this.noteHubs(live, now);
@@ -22926,12 +23810,13 @@ var Communities = class {
 	/** A member asks a hub for an edge: its key in the hub's lobby, and its side of the edge started. */
 	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, true) ?? []);
+		const back = this.wayBack(groupId, live);
+		const existing = readLobby(keys, await this.host.resolve(keys.identity.pubKeyZ32, !back, !back, back) ?? []);
 		const theirs = now - live.hubClocks.ahead(hub);
 		await this.host.publish(keys.identity, lobbyRecords(keys, mergeLobby(existing, {
 			key: live.session.myKey,
 			ts: theirs
-		}, theirs)), true, true);
+		}, theirs)), !back, !back, back);
 		(live.lobbyChecks ??= /* @__PURE__ */ new Map()).set(hub, {
 			at: now + LOBBY_CHECK_MS + Math.floor(this.random() * LOBBY_CHECK_JITTER_MS),
 			ts: Math.floor(theirs / 1e3) * 1e3
@@ -22954,7 +23839,8 @@ var Communities = class {
 	}
 	async pollLobby(groupId, live, now) {
 		const keys = lobbyKeys(live.session.state.rv, groupId, live.session.myKey);
-		const entries = readLobby(keys, await this.host.resolve(keys.identity.pubKeyZ32, true, this.doorBusy(groupId, live, now)).catch(() => null) ?? []);
+		const back = this.wayBack(groupId, live);
+		const entries = readLobby(keys, await this.host.resolve(keys.identity.pubKeyZ32, !back, !back && this.doorBusy(groupId, live, now), back).catch(() => null) ?? []);
 		for (const { key, ts } of entries) {
 			if (now - ts > COMMUNITY_TOPOLOGY.lobbyFreshMs || key === live.session.myKey) continue;
 			if (live.session.wasRemoved(key)) {
@@ -23055,6 +23941,34 @@ var Communities = class {
 		return live.hub && (now < live.warmUntil || now < live.crowdUntil || now < live.lobbyBusyUntil || this.admitting(groupId, live, now));
 	}
 	/**
+	* A member with no edge up in this community: its first reading of the beacon (who the hubs are) and its request in a
+	* hub's lobby are its way back, and go within the relays' allowance for it (`PkarrRequestOptions.back`), not as
+	* background looks. Those wait for every link that signals and every chat's look: a web app opened with 30 chats whose
+	* contacts were online read none of its 5 communities' beacons in 3 minutes, dropped the edges of its last run at 60 s,
+	* and got no community line, neither those written while it was closed nor new ones (bug hunt, 2026-10-13). Nor as a
+	* group edge's signaling: the edges of its 15 groups, all offering at once, spent that allowance in the first second,
+	* and the beacons were read a minute later or not at all (bug hunt, 2026-10-14). Bounded: the reading is asked again
+	* only when refused, and a hub that does not take me is given up after its wait (`hubWaitMs`).
+	*
+	* A hub with no edge up too (an app back from a restart steps up at once where it was one, before any edge is up): its
+	* beacon entry, read and written, and its reading of its lobby. As background looks, a daemon back as the hub of its 5
+	* communities while its 30 chats signaled got back into them one at a time, 4 to 10 minutes, one not at all in 16: its
+	* entry went unwritten, the other hubs took it for gone (`hubDead`) and its members asked them (bug hunt, 2026-10-14).
+	* Not a hub alone in the beacon: nobody carries the group without it, and its door's looks stay background ones.
+	*
+	* Alone as my last reading of the beacon said, and only while that reading is fresh. One that aged out says nothing of
+	* now: judged by my clock against it, every hub it listed went stale, and I was alone. An app back from a restart as a
+	* member of a community whose hubs did not list it read the beacon once (its way back); its edge stayed down while its
+	* other links took its relays' budget, its reading aged out, it stepped up as a hub "alone", and its readings and its
+	* entry went as background looks the relays held: it never read the beacon again, nobody listed it, and it was not
+	* back in that community in 10 minutes (bug hunt, 2026-10-17).
+	*/
+	wayBack(groupId, live) {
+		const read = live.beaconAt, now = this.now();
+		if (live.hub && now - read < COMMUNITY_TOPOLOGY.beaconFreshMs && !freshHubs(this.hubs(live), read).some((h) => h.key !== live.session.myKey)) return false;
+		return ![...this.host.edges(groupId).values()].some((id) => this.host.linkReady(id, 2));
+	}
+	/**
 	* Which knock records to read now (none, most of the time): every one at once the first time
 	* (a hub just elected, an app back, a change of door), since a knock left while nobody was at the
 	* door may be in any; then the door the bell, and the others in turn; the other hubs one in turn, slowly.
@@ -23521,6 +24435,7 @@ var Communities = class {
 				noteCame(this.stored.get(id), came, m.sender !== session.myKey, mentioned);
 			},
 			app: (m) => this.deliver(id, () => m.frame.t === "group-have" ? this.files?.communityApp(id, m.sender, m.frame) : this.host.communityApp?.(id, m.sender, m.frame)),
+			lasting: (m) => m.frame.t === "pin" && m.sender === session.admin ? "pin" : void 0,
 			pair: (m) => this.deliver(id, () => this.host.communityPair?.(id, m.sender, m.payload)),
 			changed: () => {
 				this.membershipChanged(id);
@@ -24768,6 +25683,8 @@ var Groups = class {
 	/** Admin side: entry sessions of a member key that timed out in a row, and when the last did. */
 	entryTimeouts = /* @__PURE__ */ new Map();
 	lastPoll = /* @__PURE__ */ new Map();
+	/** Admin side: when a link nobody is using was last read. Those links share one `pollMs` between them, read in turn. */
+	lastQuietPoll = 0;
 	/** Admin side: until when a group's link is looked at the warm pace. */
 	warmUntil = /* @__PURE__ */ new Map();
 	lastKnock = /* @__PURE__ */ new Map();
@@ -24798,6 +25715,12 @@ var Groups = class {
 	* whom, and when it was asked. Their sync goes once that answer has come.
 	*/
 	syncHeld = /* @__PURE__ */ new Map();
+	/**
+	* Per mesh group, the members told where I am since their edge came up (`edgeReady`), forgotten when a tick sees it
+	* down. One whose edge is up but not told yet opened in the same moment as the one being told: it is asked of that
+	* one, as if its edge were still down (`askOf`), and no gossip turn or ask for gaps goes to it before it is told.
+	*/
+	told = /* @__PURE__ */ new Map();
 	/** Per mesh group and member, when a message last came over its edge (its own, or one it handed on). */
 	lastHanded = /* @__PURE__ */ new Map();
 	/** Admin side, per group and member let in: when its welcome was last sent again, over its chat or the link (`REWELCOME_MS`). */
@@ -24863,16 +25786,16 @@ var Groups = class {
 			}
 		}, hubTimings);
 		this.typings = new GroupTypings(host);
-		this.lineOrder = new GroupLineOrder(host);
+		this.lineOrder = new GroupLineOrder(host, (linkId) => {
+			const groupId = linkId.slice(MESSAGE_LINK("").length), session = this.sessions.get(groupId);
+			return !!session && [...session.lacking().keys()].some((sender) => this.onTheirWay(groupId, sender, session.epoch));
+		});
 		const placeAgain = host.placeAgain && (async (linkId, ids) => {
 			const done = host.placeAgain(linkId, ids);
-			this.lineOrder.moved(linkId, ids);
+			this.lineOrder.moved(linkId, ids, this.now());
 			await done;
 		});
-		this.authorOrder = new GroupAuthorOrder({ placeAgain }, MESSAGE_LINK, (groupId, sender) => {
-			const session = this.sessions.get(groupId);
-			return !!session && session.missing(sender, this.gapsGone.get(groupId)?.get(sender)?.[session.epoch]) > 0;
-		});
+		this.authorOrder = new GroupAuthorOrder({ placeAgain }, MESSAGE_LINK, (groupId, sender) => this.onTheirWay(groupId, sender));
 		this.signals = new MeshSignals(host, {
 			session: (id) => this.sessions.get(id),
 			stored: (id) => this.stored.get(id),
@@ -25124,10 +26047,11 @@ var Groups = class {
 		if (this.isCommunity(groupId)) throw new Error("Share the group's link with them: anyone who opens it joins");
 		const session = this.session(groupId);
 		if (!session.isAdmin) throw new Error("Only the admin can invite");
+		if (this.host.adminWork?.(groupId) === false) throw new Error(GROUP_ADMIN_OFF_ERROR);
 		const group = this.stored.get(groupId);
 		if (Object.entries(group.contacts ?? {}).some(([key, id]) => id === linkId && rosterHas(session.roster, key))) throw new Error("This contact is already a member");
 		if (session.roster.length + (this.invited.get(groupId)?.size ?? 0) >= GROUP_MEMBER_CAP.max) throw new Error(`A group holds ${GROUP_MEMBER_CAP.max} members at most`);
-		if (!this.host.linkReady(linkId)) throw new Error("Connect to this contact first. Their app needs groups (an updated Ghostly).");
+		if (!this.host.linkReady(linkId)) throw new Error(this.host.linkOpen?.(linkId) === false ? "This contact is not connected right now. Invite them when they are online." : "Their app does not take part in groups: they need an updated Ghostly first.");
 		const blocked = this.growthBlocked(group, session, session.roster.length + (this.invited.get(groupId)?.size ?? 0) + 1, linkId);
 		if (blocked) throw new Error(blocked);
 		this.host.sendOnLink(linkId, session.inviteFrame());
@@ -25654,6 +26578,7 @@ var Groups = class {
 		this.lingering.delete(groupId);
 		this.relayAsked.delete(groupId);
 		this.syncHeld.delete(groupId);
+		this.told.delete(groupId);
 		this.lastHanded.delete(groupId);
 		this.rewelcomed.delete(groupId);
 		this.hubs.forget(groupId);
@@ -25769,6 +26694,8 @@ var Groups = class {
 		this.ticking = true;
 		try {
 			this.authorOrder.tick(now);
+			this.lineOrder.tick(now);
+			const quiet = [];
 			for (const group of [...this.stored.values()]) {
 				if (group.left) {
 					if (now - group.left.at > LEFT_KEPT_MS) await this.forget(group.id);
@@ -25810,12 +26737,25 @@ var Groups = class {
 					const linkId = this.host.entries(group.id).get(key);
 					if (linkId) await this.host.closeEdge(linkId);
 				}
-				const every = now < (this.warmUntil.get(group.id) ?? 0) ? this.timings.warmPollMs : this.timings.pollMs;
-				if (!((pending?.size ?? 0) >= MAX_PENDING_ENTRIES || session.roster.length + (pending?.size ?? 0) >= GROUP_MEMBER_CAP.max) && now - (this.lastPoll.get(group.id) ?? 0) >= every) {
+				const busy = (pending?.size ?? 0) >= MAX_PENDING_ENTRIES || session.roster.length + (pending?.size ?? 0) >= GROUP_MEMBER_CAP.max;
+				const since = now - (this.lastPoll.get(group.id) ?? 0);
+				if (busy) continue;
+				if (now >= (this.warmUntil.get(group.id) ?? 0)) {
+					if (since >= this.timings.pollMs) quiet.push(group.id);
+				} else if (since >= this.timings.warmPollMs) {
 					this.lastPoll.set(group.id, now);
 					await this.answerKnocks(group, session, now).catch(() => {});
 				}
 			}
+			if (quiet.length && now - this.lastQuietPoll >= this.timings.pollMs) {
+				const groupId = quiet.reduce((a, b) => (this.lastPoll.get(b) ?? 0) < (this.lastPoll.get(a) ?? 0) ? b : a);
+				const group = this.stored.get(groupId), session = this.sessions.get(groupId);
+				if (group?.entry && !group.left && session?.isAdmin) {
+					this.lastQuietPoll = now;
+					this.lastPoll.set(groupId, now);
+					await this.answerKnocks(group, session, now).catch(() => {});
+				}
+			}
 			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);
@@ -25919,7 +26859,16 @@ var Groups = class {
 	/** The member at the other end of an entry session (the joiner, on the admin's side) or of a chat an invitation went over. */
 	linkMember(groupId, linkId) {
 		for (const [peer, id] of this.host.entries(groupId)) if (id === linkId) return peer;
-		return Object.entries(this.stored.get(groupId)?.contacts ?? {}).find(([, id]) => id === linkId)?.[0];
+		return this.chatMember(groupId, linkId);
+	}
+	/**
+	* The member a chat an invitation went over is: one removed and invited back over the same chat has its old key on it
+	* too (`contacts` keeps it for the removal notice), so the key in the roster, else the newest.
+	*/
+	chatMember(groupId, linkId) {
+		const keys = Object.entries(this.stored.get(groupId)?.contacts ?? {}).filter(([, id]) => id === linkId).map(([key]) => key);
+		const roster = this.sessions.get(groupId)?.roster;
+		return roster && keys.find((key) => rosterHas(roster, key)) || keys[keys.length - 1];
 	}
 	/**
 	* My packet for the edge to `to`, handed to links that reach that member or may pass it on (WISP 902 · Group Mesh
@@ -26312,8 +27261,7 @@ var Groups = class {
 			}
 			case "group-leave": {
 				const session = this.sessions.get(g);
-				const group = this.stored.get(g);
-				const member = Object.entries(group?.contacts ?? {}).find(([, id]) => id === linkId)?.[0];
+				const member = this.chatMember(g, linkId);
 				if (!session?.isAdmin || !member || member === session.myKey) return;
 				if (rosterHas(session.roster, member)) await session.remove(member, Date.now(), { left: true }).catch(() => {});
 				try {
@@ -26457,6 +27405,9 @@ var Groups = class {
 			return;
 		}
 		if (!session || !group || session.status !== "active" || !rosterHas(session.roster, peerKey)) return;
+		let told = this.told.get(groupId);
+		if (!told) this.told.set(groupId, told = /* @__PURE__ */ new Set());
+		told.add(peerKey);
 		const seen = !!group.unseen?.includes(peerKey);
 		if (seen) {
 			const unseen = group.unseen.filter((key) => key !== peerKey);
@@ -26466,7 +27417,7 @@ var Groups = class {
 		const legacy = this.hubs.enabled && this.hubs.edgeReady(groupId, session, group, peerKey, this.host.linkReady(linkId, 4), this.now());
 		if (large || legacy || seen) this.store.putGroup(group).catch(() => {});
 		if (!this.holdSync(groupId, peerKey)) try {
-			this.host.sendOnLink(linkId, session.syncFrame(this.askOf(groupId, session, peerKey)));
+			this.host.sendOnLink(linkId, session.syncFrame(this.askOf(groupId, session, peerKey), peerKey));
 		} catch {
 			return;
 		}
@@ -26602,18 +27553,21 @@ var Groups = class {
 	}
 	/**
 	* The unreachable members whose messages `via` should hand on to me: each is asked of one connected member at a
-	* time, so a member whose edges open one after another is not sent the same messages by each of them.
+	* time, so a member whose edges open one after another is not sent the same messages by each of them. Those whose
+	* edge opened in the same moment, not told yet, are asked of `via` too, and their syncs wait for its answer
+	* (`holdSync`): each told at once answered with its own lines alone, and a conversation two of them had while I was
+	* away came as all of one's lines, then all of the other's.
 	*/
 	askOf(groupId, session, via) {
 		let asked = this.relayAsked.get(groupId);
 		if (!asked) this.relayAsked.set(groupId, asked = /* @__PURE__ */ new Map());
-		const edges = this.host.edges(groupId), now = this.now();
+		const edges = this.host.edges(groupId), now = this.now(), told = this.told.get(groupId);
 		const up = (key) => {
 			const edge = edges.get(key);
 			return !!edge && this.host.linkReady(edge);
 		};
 		const out = [];
-		for (const key of this.unreachable(groupId, session)) {
+		for (const key of session.others.filter((key) => !up(key) || !told?.has(key))) {
 			if (key === via) continue;
 			const prior = asked.get(key);
 			if (prior && up(prior.via) && now - prior.at < 6e4) continue;
@@ -26694,7 +27648,7 @@ var Groups = class {
 			});
 		}
 		try {
-			this.host.sendOnLink(edges.get(next), session.syncFrame([...ask]));
+			this.host.sendOnLink(edges.get(next), session.syncFrame([...ask], next));
 		} catch {}
 	}
 	/**
@@ -26715,9 +27669,9 @@ var Groups = class {
 		for (const key of tried.keys()) if (!lacking.has(key)) tried.delete(key);
 		const out = [];
 		for (const [key, mark] of lacking) {
-			if (key === via || !up(key)) continue;
+			if (key === via || !up(key) || !session.mayHold(via, key)) continue;
 			const prior = asked.get(key);
-			if (prior && prior.via !== via && up(prior.via) && now - prior.at < 6e4) continue;
+			if (prior && prior.via !== via && up(prior.via) && now - prior.at < 6e4 && session.mayHold(prior.via, key)) continue;
 			let entry = tried.get(key);
 			if (!entry || entry.mark !== mark) tried.set(key, entry = {
 				mark,
@@ -26763,6 +27717,11 @@ var Groups = class {
 		entry.at = now;
 		return true;
 	}
+	/** Whether some of a member's messages are still on their way (not known gone): in any epoch, or in those below `below`. */
+	onTheirWay(groupId, sender, below = Infinity) {
+		const gone = this.gapsGone.get(groupId)?.get(sender);
+		return Object.entries(this.sessions.get(groupId)?.missOf(sender) ?? {}).some(([e, gaps]) => Number(e) < below && gaps.some((n) => n > (gone?.[e] ?? -1)));
+	}
 	/**
 	* Messages nobody holds any more: every connected member, their author included, was asked for the same missing
 	* numbers `MESH_GAP_AGAIN_MS` ago or more and none arrived. An author keeps its last 32 and the others the group's
@@ -26776,7 +27735,7 @@ var Groups = class {
 		for (const [key, mark] of lacking) {
 			const entry = tried.get(key);
 			if (!entry || entry.mark !== mark || entry.at === void 0 || now - entry.at < 1e4) continue;
-			if (!connected.includes(key) || !connected.every((member) => entry.of.has(member))) continue;
+			if (!connected.includes(key) || !connected.every((member) => entry.of.has(member) || !session.mayHold(member, key))) continue;
 			let gone = this.gapsGone.get(groupId);
 			if (!gone) this.gapsGone.set(groupId, gone = /* @__PURE__ */ new Map());
 			const upTo = { ...gone.get(key) };
@@ -26826,7 +27785,9 @@ var Groups = class {
 				continue;
 			}
 			if (now - last.at < 1e4 || !up(last.via)) continue;
-			if (session.filledSince(key, last.asked)) again.set(last.via, [...again.get(last.via) ?? [], key]);
+			if (!session.filledSince(key, last.asked)) continue;
+			if (session.mayHold(last.via, key)) again.set(last.via, [...again.get(last.via) ?? [], key]);
+			else fresh.set(key, mark);
 		}
 		const asked = this.relayAsked.get(groupId);
 		for (const [via, keys] of again) {
@@ -26847,18 +27808,19 @@ var Groups = class {
 				});
 			}
 			try {
-				this.host.sendOnLink(edges.get(via), session.syncFrame(keys));
+				this.host.sendOnLink(edges.get(via), session.syncFrame(keys, via));
 			} catch {}
 		}
 		if (!fresh.size || !connected.length) return;
 		const at = () => connected[(gossipStart(session.myKey) + this.gossipTurn++) % connected.length];
+		const helps = (member) => !fresh.has(member) && [...fresh.keys()].some((key) => session.mayHold(member, key));
 		let via = at();
-		for (let i = 1; i < connected.length && fresh.has(via); i++) via = at();
+		for (let i = 1; i < connected.length && !helps(via); i++) via = at();
 		const keys = this.gapsOf(groupId, session, via, fresh);
 		if (!keys.length) return;
 		this.lastGossip.set(groupId, now);
 		try {
-			this.host.sendOnLink(edges.get(via), session.syncFrame(keys));
+			this.host.sendOnLink(edges.get(via), session.syncFrame(keys, via));
 		} catch {}
 	}
 	/**
@@ -26880,9 +27842,12 @@ var Groups = class {
 				const edges = this.host.edges(groupId);
 				if (!this.hubs.large(session) && session.others.some((key) => !edges.has(key))) this.reconcileEdges(groupId);
 			}
-			const away = this.unreachable(groupId, session);
-			this.noteDown(groupId, session, away, now);
-			const connected = session.others.filter((key) => !away.includes(key));
+			const down = this.unreachable(groupId, session);
+			this.noteDown(groupId, session, down, now);
+			const told = this.told.get(groupId);
+			for (const key of down) told?.delete(key);
+			const connected = session.others.filter((key) => !down.includes(key) && told?.has(key));
+			const away = session.others.filter((key) => !connected.includes(key));
 			this.gapsAgain(groupId, session, now, connected);
 			if (now - (this.lastGossip.get(groupId) ?? -Infinity) < 6e4) continue;
 			const edges = this.host.edges(groupId);
@@ -26900,7 +27865,7 @@ var Groups = class {
 			const ask = [...away, ...this.gapsOf(groupId, session, via, lacking)];
 			if (!this.ownGap(groupId, via, lacking) && !ask.length) continue;
 			try {
-				this.host.sendOnLink(edges.get(via), session.syncFrame(ask));
+				this.host.sendOnLink(edges.get(via), session.syncFrame(ask, via));
 			} catch {}
 		}
 	}
@@ -27004,21 +27969,27 @@ var Groups = class {
 					...m.frame && { frame: m.frame }
 				};
 				const completed = !!m.completes && !!this.host.completeMessage;
+				const row = {
+					sender: m.sender,
+					epoch: m.epoch,
+					seq: m.seq,
+					id: m.id
+				};
+				const above = completed || m.sender === session.myKey ? void 0 : this.authorOrder.above(state.id, row);
+				const place = above === void 0 ? void 0 : await this.host.placeAbove?.(message.linkId, above).catch(() => void 0);
+				const placedAbove = place === void 0 ? void 0 : above;
 				const placing = completed ? void 0 : this.lineOrder.placing(MESSAGE_LINK(state.id), {
 					id: m.id,
 					epoch: m.epoch,
 					line: false
-				}, this.now());
-				const stored = completed ? (await this.host.completeMessage(message), false) : await this.host.storeMessage(message);
+				}, this.now(), placedAbove);
+				const stored = completed ? (await this.host.completeMessage(message), false) : await this.host.storeMessage(message, m.live, place);
 				placing?.(stored !== false);
 				if (m.frame && (completed || stored !== false)) await this.frameKept(state.id, m.id, m.frame);
 				if (!completed && stored !== false) this.authorOrder.placed(state.id, {
-					sender: m.sender,
-					epoch: m.epoch,
-					seq: m.seq,
-					id: m.id,
+					...row,
 					at: this.now()
-				});
+				}, placedAbove);
 				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));
@@ -30241,7 +31212,10 @@ var SWAP_POLL_MS = 3e4;
 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) {
+/** Cashu's library (174 KiB) loads with the wallet's first use of a mint or a token, not with the app's start. */
+var loadCashu = () => import("@cashu/cashu-ts");
+async function reviewedCashuFee(preview) {
+	const { Amount } = await loadCashu();
 	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;
@@ -30297,9 +31271,9 @@ 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 swapId = () => `swap-${Date.now()}-${crypto.randomUUID().slice(0, 8)}`;
 var walletTx = (mint, kind, amount, fee, note) => ({
-	id: `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`,
+	id: `${Date.now()}-${crypto.randomUUID().slice(0, 8)}`,
 	timestamp: Date.now(),
 	mint,
 	kind,
@@ -30608,6 +31582,7 @@ var CashuWallet = class CashuWallet {
 		const quote = await wrap((await store(STORES$1.quotes, "readonly")).get(id));
 		if (!quote || quote.issuedUnclaimed || quote.held) return null;
 		const wallet = await this.wallet(quote.mint);
+		const { OutputData, isMintOperationError } = await loadCashu();
 		const answer = await wallet.checkMintQuoteBolt11(quote.quote);
 		const { state } = answer;
 		if (state === "UNPAID") {
@@ -30651,7 +31626,10 @@ var CashuWallet = class CashuWallet {
 	/** 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);
+		const tx = {
+			...walletTx(quote.mint, "lightning-in", minted, quote.amount - minted, quote.paymentId ? "Request paid over Lightning" : quote.testCoins ? TEST_COINS_NOTE : void 0),
+			quote: quote.quote
+		};
 		await transact([
 			STORES$1.proofs,
 			STORES$1.walletTx,
@@ -30687,7 +31665,7 @@ var CashuWallet = class CashuWallet {
 			if (await this.balanceAt(mint) < amount) continue;
 			return this.locked(mint, async () => {
 				const { inputs, keep, send, swap } = await this.split(mint, amount, await this.proofsAt(mint));
-				const token = getEncodedToken({
+				const token = (await loadCashu()).getEncodedToken({
 					mint,
 					proofs: send,
 					unit: UNIT$1
@@ -30721,10 +31699,10 @@ var CashuWallet = class CashuWallet {
 		return this.locked(mint, async () => {
 			const preview = await (await this.wallet(mint)).ops.send(amount, asProofLike(await this.proofsAt(mint))).includeFees(true).prepare();
 			return {
-				fee: reviewedCashuFee(preview),
+				fee: await reviewedCashuFee(preview),
 				prepared: {
 					mint,
-					swap: serializeSwapPreview(preview)
+					swap: (await loadCashu()).serializeSwapPreview(preview)
 				}
 			};
 		});
@@ -30732,8 +31710,8 @@ var CashuWallet = class CashuWallet {
 	/** Reserve before the mint call. A timeout keeps these inputs reserved for read-only recovery. */
 	async executeReviewedCashu(review, prepared) {
 		return this.locked(prepared.mint, async () => {
-			const preview = deserializeSwapPreview(prepared.swap);
-			if (prepared.mint !== review.provider || preview.amount.toNumber() !== review.amount || reviewedCashuFee(preview) !== review.fee) throw new PaymentPreflightError("Cashu preview does not match review");
+			const preview = (await loadCashu()).deserializeSwapPreview(prepared.swap);
+			if (prepared.mint !== review.provider || preview.amount.toNumber() !== review.amount || await reviewedCashuFee(preview) !== review.fee) throw new PaymentPreflightError("Cashu preview does not match review");
 			const tx = (await openDb()).transaction(STORES$1.proofs, "readwrite");
 			await new Promise((resolve, reject) => {
 				const proofs = tx.objectStore(STORES$1.proofs);
@@ -30763,6 +31741,7 @@ var CashuWallet = class CashuWallet {
 		const stored = await wrap((await store(STORES$1.payments, "readonly")).get(review.id));
 		if (stored?.token) return stored.token;
 		const wallet = await this.wallet(prepared.mint);
+		const { OutputData } = await loadCashu();
 		const keep = (prepared.swap.keepOutputs ?? []).map(OutputData.deserialize);
 		const send = (prepared.swap.sendOutputs ?? []).map(OutputData.deserialize);
 		const outputs = [...keep, ...send];
@@ -30792,6 +31771,7 @@ var CashuWallet = class CashuWallet {
 		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 { Amount } = await loadCashu();
 		const restored = [];
 		for (const output of outputs) {
 			const index = recovered.outputs.findIndex((o) => o.B_ === output.blindedMessage.B_);
@@ -30803,6 +31783,7 @@ var CashuWallet = class CashuWallet {
 		return restored;
 	}
 	async finishReviewedCashu(review, prepared, keep, send) {
+		const { getEncodedToken, deserializeSwapPreview } = await loadCashu();
 		const token = getEncodedToken({
 			mint: prepared.mint,
 			proofs: send,
@@ -30845,6 +31826,7 @@ var CashuWallet = class CashuWallet {
 	* not SPENT), and the mint signed none of its outputs. Read-only: it asks, and never sends the swap.
 	*/
 	async reviewedCashuNeverSwapped(prepared) {
+		const { OutputData, deserializeSwapPreview } = await loadCashu();
 		const preview = deserializeSwapPreview(prepared.swap);
 		if (!preview.inputs.length) return false;
 		const wallet = await this.wallet(prepared.mint);
@@ -30863,6 +31845,7 @@ var CashuWallet = class CashuWallet {
 	* pending. Read-only. A mint that does not restore cannot say, and the answer is no.
 	*/
 	async reviewedCashuSpentElsewhere(prepared) {
+		const { OutputData, deserializeSwapPreview } = await loadCashu();
 		const preview = deserializeSwapPreview(prepared.swap);
 		if (!preview.inputs.length) return false;
 		const wallet = await this.wallet(prepared.mint);
@@ -30880,7 +31863,7 @@ var CashuWallet = class CashuWallet {
 	* 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);
+		const preview = (await loadCashu()).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,
@@ -30925,7 +31908,7 @@ var CashuWallet = class CashuWallet {
 	}
 	/** Gives back the inputs a reviewed swap reserved, once the mint proved it never happened. Idempotent. */
 	async releaseReviewedCashu(prepared) {
-		const preview = deserializeSwapPreview(prepared.swap);
+		const preview = (await loadCashu()).deserializeSwapPreview(prepared.swap);
 		await this.locked(prepared.mint, async () => {
 			await transact([STORES$1.proofs], (stores) => {
 				const proofs = stores[STORES$1.proofs];
@@ -30950,7 +31933,7 @@ var CashuWallet = class CashuWallet {
 		return (await wrap((await store(STORES$1.payments, "readonly")).get(id)))?.state === "reclaimed";
 	}
 	async reviewedCashuSpent(prepared) {
-		const outputs = (prepared.swap.sendOutputs ?? []).map(OutputData.deserialize);
+		const outputs = (prepared.swap.sendOutputs ?? []).map((await loadCashu()).OutputData.deserialize);
 		const states = await (await this.wallet(prepared.mint)).checkProofsStates(outputs.map((o) => ({
 			secret: new TextDecoder().decode(o.secret),
 			id: o.blindedMessage.id
@@ -30958,8 +31941,10 @@ var CashuWallet = class CashuWallet {
 		return states.length > 0 && states.length === outputs.length && states.every((s) => s.state === "SPENT");
 	}
 	/** Reads a token or a payment request without contacting a mint. Nothing here moves money. */
-	inspect(text) {
+	async inspect(text) {
 		const value = text.trim();
+		if (!/^(cashu|creq)[AB]/i.test(value)) return null;
+		const { decodePaymentRequest, getTokenMetadata } = await loadCashu();
 		try {
 			if (/^cashu[AB]/i.test(value)) {
 				const metadata = getTokenMetadata(value);
@@ -30994,6 +31979,7 @@ var CashuWallet = class CashuWallet {
 		let mint;
 		let faceValue;
 		let unit;
+		const { getTokenMetadata, serializeSwapPreview } = await loadCashu();
 		try {
 			const metadata = getTokenMetadata(token);
 			unit = metadata.unit;
@@ -31064,6 +32050,7 @@ var CashuWallet = class CashuWallet {
 	*/
 	async split(mint, amount, proofs) {
 		const wallet = await this.wallet(mint);
+		const { getEncodedToken, serializeSwapPreview } = await loadCashu();
 		const among = (chosen) => {
 			const secrets = new Set(chosen.map((p) => p.secret));
 			return proofs.filter((p) => secrets.has(p.secret));
@@ -31115,6 +32102,7 @@ var CashuWallet = class CashuWallet {
 	* `pollSwaps` settles it. Runs under the mint's lock.
 	*/
 	async completeSwap(swap) {
+		const { deserializeSwapPreview, isMintOperationError } = await loadCashu();
 		try {
 			return await (await this.wallet(swap.mint)).completeSwap(deserializeSwapPreview(swapOf(swap)));
 		} catch (error) {
@@ -31142,6 +32130,7 @@ var CashuWallet = class CashuWallet {
 	*/
 	async swapOutcome(swap, refused = false) {
 		const wallet = await this.wallet(swap.mint);
+		const { OutputData } = await loadCashu();
 		const saved = swapOf(swap);
 		const keep = (saved.keepOutputs ?? []).map(OutputData.deserialize);
 		const send = (saved.sendOutputs ?? []).map(OutputData.deserialize);
@@ -31300,6 +32289,15 @@ var CashuWallet = class CashuWallet {
 	settleSwaps(mints) {
 		return this.pollSwaps(mints);
 	}
+	/**
+	* A contact's ecash for this request of ours is being redeemed: written down, and the mint has not said how it ended,
+	* or it has and its chat was not told yet. Released: the mint never made it in time, and the ecash went back. Stuck
+	* past its watch hour (spent, and a mint that cannot say by what): kept to be asked about, but no longer expected to
+	* pay the request, which another member may pay.
+	*/
+	async redeemingFor(requestId) {
+		return (await wrap((await store(STORES$1.swaps, "readonly")).getAll())).some((s) => s.kind === "receive" && !s.released && s.payment?.requestId === requestId && !(s.stuck && Date.now() >= s.createdAt + SWAP_WATCH_MS));
+	}
 	async pollSwaps(mints) {
 		if (!mints) {
 			if (this.swapTimer) clearTimeout(this.swapTimer);
@@ -31347,34 +32345,36 @@ var CashuWallet = class CashuWallet {
 						}));
 						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$1.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$1.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)) {
+					} else if (outcome.idle && swap.kind === "receive" && !swap.released) {
+						const { deserializeSwapPreview, isMintOperationError } = await loadCashu();
+						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$1.swaps, "readwrite")).delete(swap.id));
+								else if (swap.payment) later(SWAP_POLL_MS);
+								this.events.onChange();
 							}
-							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 if (outcome.pending && swap.kind === "receive" && !swap.released && Date.now() >= swapOverdueAt(swap)) {
+						} catch (error) {
+							swap = {
+								...swap,
+								attemptEndedAt: Date.now()
+							};
+							await wrap((await store(STORES$1.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$1.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 if (outcome.pending && swap.kind === "receive" && !swap.released && Date.now() >= swapOverdueAt(swap)) {
 						if (Date.now() < swap.createdAt + SWAP_WATCH_MS) {
 							await wrap((await store(STORES$1.swaps, "readwrite")).put({
 								...swap,
@@ -31468,6 +32468,7 @@ var CashuWallet = class CashuWallet {
 	}
 	async melt(quoteId, mint, note, paymentId) {
 		const wallet = await this.wallet(mint);
+		const { MeltChangeError, OutputData, isMintOperationError } = await loadCashu();
 		const quote = await wallet.checkMeltQuoteBolt11(quoteId);
 		if ((await wrap((await store(STORES$1.melts, "readonly")).getAll())).some((m) => m.quote === quote.quote || m.request === quote.request)) throw new Error("This invoice is already being paid");
 		const shown = this.shownQuotes.get(quoteId);
@@ -31561,6 +32562,7 @@ var CashuWallet = class CashuWallet {
 	*/
 	async settleMelt(melt) {
 		const wallet = await this.wallet(melt.mint);
+		const { Amount, OutputData } = await loadCashu();
 		const quote = await wallet.checkMeltQuoteBolt11(melt.quote);
 		if (quote.state === "PAID") {
 			const signatures = (quote.change ?? []).filter((sig) => !Amount.from(sig.amount).isZero());
@@ -31666,7 +32668,7 @@ var CashuWallet = class CashuWallet {
 			out.push({
 				mint,
 				amount: total(proofs),
-				token: getEncodedToken({
+				token: (await loadCashu()).getEncodedToken({
 					mint,
 					proofs,
 					unit: UNIT$1
@@ -31679,7 +32681,7 @@ var CashuWallet = class CashuWallet {
 		let wallet = this.wallets.get(mint);
 		if (!wallet) {
 			wallet = (async () => {
-				const instance = new Wallet(mint, { unit: UNIT$1 });
+				const instance = new (await (loadCashu())).Wallet(mint, { unit: UNIT$1 });
 				await within(MINT_TIMEOUT_MS, instance.loadMint(), mint);
 				return instance;
 			})();
@@ -32319,12 +33321,14 @@ var PaymentDesk = class {
 		return request.linkId === linkId || !!request.group && this.host.groupOf?.(linkId) === request.group;
 	}
 	/**
-	* Why a token cannot pay a request to the group, checked before anything is redeemed: already paid, or it would
-	* not settle it (too little, a mint the request did not name). Undefined when it can.
+	* Why a token cannot pay a request to the group, checked before anything is redeemed: already paid, another member's
+	* ecash for it still being redeemed (the mint has not answered), or it would not settle it (too little, a mint the
+	* request did not name). Undefined when it can.
 	*/
-	refuseForGroup(request, payment) {
+	async refuseForGroup(request, payment) {
 		if (request.state !== "pending") return "Already paid by another member of the group";
-		const token = this.wallet.inspect?.(payment.endpoint[1]);
+		if (await this.wallet.redeemingFor?.(request.id)) return "Another member of the group is paying it";
+		const token = await this.wallet.inspect?.(payment.endpoint[1]);
 		if (token && token.kind === "token" && (token.amount < request.amount || !(request.mints ?? []).includes(token.mint))) return "This ecash does not pay the request: the amount or the mint differs";
 	}
 	/**
@@ -32416,6 +33420,24 @@ var PaymentDesk = class {
 		}).catch(() => {});
 	}
 	/**
+	* A Testnet invoice found in a chat message, paid from its card: the chat's contact is told as `sayPaid` does, with
+	* no request (it may be one from their Receive screen, held until a payer says it paid).
+	*/
+	sayInvoicePaid(linkId, invoice) {
+		const link = this.host.getLink(linkId);
+		const amount = decodeBolt11(invoice)?.amountSat;
+		if (!link || !amount) return;
+		this.sendTo(link, {
+			id: newId(),
+			timestamp: Date.now(),
+			amount: {
+				value: String(amount),
+				asset: UNIT
+			},
+			endpoint: [ENDPOINT.bolt11, invoice.trim()]
+		}).catch(() => {});
+	}
+	/**
 	* Takes back ecash the peer never redeemed. If they did redeem it, the mint says so and the payment is settled.
 	* Resolves to what came back of Cashu ecash (and the mint's fee for it); undefined when nothing did, or not Cashu.
 	*/
@@ -32752,7 +33774,7 @@ var PaymentDesk = class {
 			});
 			return;
 		}
-		const inspected = this.wallet.inspect?.(payment.endpoint[1]);
+		const inspected = await this.wallet.inspect?.(payment.endpoint[1]);
 		if (payment.endpoint[0] === ENDPOINT.cashu && inspected !== void 0 && inspected?.kind !== "token") {
 			link.sendPaymentResult({
 				id: payment.id,
@@ -32771,7 +33793,7 @@ var PaymentDesk = class {
 		}
 		const forGroup = payment.requestId ? this.payments.get(payment.requestId) : void 0;
 		if (forGroup?.group && forGroup.kind === "request" && forGroup.direction === "out" && this.owns(forGroup, linkId)) {
-			const refused = this.refuseForGroup(forGroup, payment);
+			const refused = await this.refuseForGroup(forGroup, payment);
 			if (refused) {
 				link.sendPaymentResult({
 					id: payment.id,
@@ -33039,6 +34061,7 @@ var PaymentDesk = class {
 	*/
 	async receiveCheck(linkId, payment) {
 		const link = this.host.getLink(linkId);
+		if (link && !payment.requestId && payment.endpoint[0] === ENDPOINT.bolt11) return this.receiveInvoicePaid(linkId, link, payment.endpoint[1]);
 		const request = payment.requestId ? this.payments.get(payment.requestId) : void 0;
 		if (!link || !request || request.kind !== "request" || request.direction !== "out" || !this.owns(request, linkId)) return;
 		const rail = request.target ? request.target.method : request.invoice ? "lightning" : void 0;
@@ -33061,6 +34084,22 @@ var PaymentDesk = class {
 			else await this.reconcileArkReceipts();
 		} catch {}
 	}
+	/**
+	* The contact says it paid an invoice of ours it found in the chat, with no request: a Receive-screen invoice is
+	* held on a test mint until then (StoredQuote `held`), and that one alone is let go. A request's invoice is spoken
+	* for by its own contact only (`receiveCheck`). Bounded: one look every 3 seconds per chat.
+	*/
+	async receiveInvoicePaid(linkId, link, invoice) {
+		if (!link.allowsPayment("lightning")) return;
+		const now = Date.now();
+		if (now - (this.lastCheckFrom.get(`chat:${linkId}`) ?? 0) < 3e3) return;
+		this.lastCheckFrom.set(`chat:${linkId}`, now);
+		const wanted = invoice.trim().toLowerCase();
+		try {
+			const quote = (await this.wallet.quotes()).find((q) => q.held && !q.paymentId && q.invoice.toLowerCase() === wanted);
+			if (quote) await this.wallet.vouch(quote.invoice);
+		} catch {}
+	}
 	/** A Lightning payment of a contact's request that was left pending (or unknown) settled. */
 	async onLightningResolved(op, paid) {
 		const found = op.paymentId ? this.payments.get(op.paymentId) : void 0;
@@ -34505,7 +35544,7 @@ function writtenAt(message, leads) {
 }
 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 }) {
+function messageAttention(type, message, { startedAt, newest, now, lateAt }) {
 	if (message.timestamp < startedAt || message.file || message.paymentId || JOIN_NOTICE.test(message.text)) return null;
 	if (message.event) {
 		const cue = groupCue(message);
@@ -34521,6 +35560,7 @@ function messageAttention(type, message, { startedAt, newest, now }) {
 	};
 	if (!message.text.trim()) return null;
 	if (newest !== void 0 && message.timestamp < newest - 6e4 && now - message.timestamp > 6e4) return null;
+	if (lateAt !== void 0 && now - lateAt < 5e3 && now - message.timestamp > 6e4) return null;
 	return {
 		type,
 		mention: !!message.mentioned
@@ -34959,6 +35999,11 @@ var GhostlyNode = class GhostlyNode {
 	transfersRestored = false;
 	/** `start` has loaded the groups (EngineState.groupsLoaded). */
 	groupsLoaded = false;
+	/** Settles as `start` has loaded the groups: a group's history reads as stored from then on (`EngineServer.handle`). */
+	groupsLoadedNow;
+	groupsRead = new Promise((resolve) => {
+		this.groupsLoadedNow = resolve;
+	});
 	feedbackStartedAt = Date.now();
 	feedbackIds = /* @__PURE__ */ new Set();
 	walletFeedbackReady = false;
@@ -34983,28 +36028,43 @@ var GhostlyNode = class GhostlyNode {
 	}
 	/** The newest time written in each chat while this engine runs: a message written well before it is a catch-up. */
 	newestAt = /* @__PURE__ */ new Map();
+	/** Per group: when the last message written well before it came, came. What comes after it, as old, is its catch-up. */
+	lateAt = /* @__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`).
+	* Each 1:1 chat's contact, and each group's member (`clockOf`): how far the time its latest live messages said was
+	* from when they came (`CLOCK_SAMPLES` of them). What tells a 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));
+	/** Whose clock a row's time is: a 1:1 chat's contact, or the group's member who wrote it. */
+	clockOf(message) {
+		return message.linkId.startsWith("group:") ? `${message.linkId} ${message.member ?? ""}` : message.linkId;
+	}
+	/**
+	* A contact's row came on the live session of a 1:1 chat, or a member's straight from its author (`live`, never one
+	* handed on or caught up): what it says of that clock is kept.
+	*/
+	clockSample(message, live = false) {
+		if (message.sender !== "peer" || message.sentAt === void 0 || message.event || message.via !== "datalink") return;
+		if (message.linkId.startsWith("group:") && !(live && message.member)) return;
+		const clock = this.clockOf(message);
+		this.clockLeads.set(clock, [...this.clockLeads.get(clock) ?? [], 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 written = writtenAt(message, this.clockLeads.get(this.clockOf(message))), now = Date.now();
+		const group = type === "message" && message.linkId.startsWith("group:"), lateAt = group ? this.lateAt.get(message.linkId) : void 0;
 		const attention = messageAttention(type, {
 			...message,
-			timestamp: writtenAt(message, this.clockLeads.get(message.linkId))
+			timestamp: written
 		}, {
 			startedAt: this.feedbackStartedAt,
 			newest,
-			now: Date.now()
+			now,
+			...lateAt !== void 0 && { lateAt }
 		});
+		if (group && !message.event && now - written > 6e4) this.lateAt.set(message.linkId, now);
 		if (attention) this.feedback(attention.type, message.linkId + ":" + message.id, message.linkId, attention.mention, attention.cue);
 	}
 	/**
@@ -35549,6 +36609,8 @@ var GhostlyNode = class GhostlyNode {
 			}
 		}
 	});
+	/** x401 credentials (WISP 3xx): kept for websites the headless CLI calls, never shared with a contact. */
+	x401 = new X401Credentials();
 	/** Identity proofs: this profile's, and those shared in each paired chat (WISP 300). */
 	identities = new IdentityProofs({
 		ledger: (linkId) => {
@@ -35610,6 +36672,59 @@ var GhostlyNode = class GhostlyNode {
 			return this.transport.publishPayload(pubKeyZ32, payload, { background: true });
 		}
 	});
+	/** The profile's contact link (WISP 8xx): one link that names nobody, its record kept on Pkarr while online. */
+	contactLinks = new ContactLinks({
+		online: () => this.networkOn,
+		emit: () => this.emitState(),
+		publish: (identity, records) => this.transport.publish(identity, records, { background: true }),
+		resolve: async (pubKeyZ32) => (await this.transport.resolve(pubKeyZ32, { background: true }))?.records ?? null,
+		ownInvite: (code) => {
+			const params = decodeInviteCode(code);
+			return !params || inviteOwnership(params, [...this.links.values()].map((l) => l.stored)).kind !== "new";
+		},
+		accept: async (request) => {
+			const params = decodeInviteCode(request.invite);
+			if (!params || inviteOwnership(params, [...this.links.values()].map((l) => l.stored)).kind !== "new") throw new Error("This request's invite is for a chat you already have.");
+			const { linkId } = await this.joinLink({ inviteCode: request.invite });
+			this.renameLink({
+				linkId,
+				label: request.name
+			});
+			await this.storeMessage({
+				linkId,
+				id: `peer_contact_${request.key.slice(0, 32)}`,
+				text: request.text,
+				sender: "peer",
+				timestamp: Math.min(request.issued, request.receivedAt),
+				via: "pkarr"
+			});
+			return linkId;
+		}
+	});
+	/** Requests this profile sends through others' contact links (WISP 8xx). */
+	contactAsks = new ContactAsks({
+		online: () => this.networkOn,
+		emit: () => this.emitState(),
+		publish: (identity, records) => this.transport.publish(identity, records, { background: true }),
+		resolve: async (pubKeyZ32) => (await this.transport.resolve(pubKeyZ32, { background: true }))?.records ?? null,
+		createChat: async ({ label, text }) => {
+			const chat = await this.createLink();
+			if (label) this.renameLink({
+				linkId: chat.linkId,
+				label
+			});
+			await this.storeMessage({
+				linkId: chat.linkId,
+				id: `me_contact_${crypto.randomUUID()}`,
+				text,
+				sender: "me",
+				timestamp: Date.now(),
+				via: "pkarr"
+			});
+			return chat;
+		},
+		ownLink: (linkKeyZ32) => this.contactLinks.owns(linkKeyZ32)
+	});
 	/** The Nostr social layer (profile, follows, notes, publication) on top of verified Nostr proofs. */
 	nostrSocial = new NostrSocial({
 		settings: () => this.settings.nostr,
@@ -35812,13 +36927,15 @@ var GhostlyNode = class GhostlyNode {
 			const live = this.links.get(linkId);
 			return !!live?.lastSyncAt && !!live.presence?.online && presenceSeenAt(live.presence) > live.lastSyncAt;
 		},
-		publish: (identity, records, background, door) => this.groupTransport.publish(identity, records, {
+		publish: (identity, records, background, door, back) => this.groupTransport.publish(identity, records, {
 			background,
-			door
+			door,
+			back
 		}),
-		resolve: async (pubKeyZ32, background, door) => (await this.groupTransport.resolve(pubKeyZ32, {
+		resolve: async (pubKeyZ32, background, door, back) => (await this.groupTransport.resolve(pubKeyZ32, {
 			background,
-			door
+			door,
+			back
 		}))?.records ?? null,
 		expectPeer: (linkId) => this.links.get(linkId)?.link?.expectPeer(),
 		signalIn: (linkId, payload, direct) => !!this.links.get(linkId)?.carried?.accept(payload, direct),
@@ -35832,7 +36949,7 @@ var GhostlyNode = class GhostlyNode {
 			else this.closeGroupLink(linkId).catch(() => {});
 		},
 		edgeNick: (linkId) => this.links.get(linkId)?.presence.nick || void 0,
-		storeMessage: (message) => this.storeNewMessage(message),
+		storeMessage: (message, live, place) => this.storeNewMessage(message, live, place),
 		completeMessage: (message) => this.completeGroupMessage(message),
 		forgetFrame: async (linkId, id) => {
 			await db.patchMessage(linkId, id, (stored) => stored.frame ? { frame: void 0 } : null, true);
@@ -35841,6 +36958,7 @@ var GhostlyNode = class GhostlyNode {
 			await db.patchMessage(linkId, id, () => ({ frame }), true);
 		},
 		placeAgain: (linkId, ids) => this.placeAgain(linkId, ids),
+		placeAbove: (linkId, id) => this.placeAbove(linkId, id),
 		membersChanged: (groupId) => this.groupMembersChanged(groupId),
 		historyGone: (groupId) => this.groupHistoryGone(groupId),
 		emit: () => this.emitState(),
@@ -36255,34 +37373,44 @@ var GhostlyNode = class GhostlyNode {
 		await this.did.load();
 		setOwnDidSource(() => this.did.id);
 		this.did.start();
+		await this.contactLinks.load();
+		this.contactLinks.start();
+		await this.contactAsks.load();
+		this.contactAsks.start();
 		await this.nostrSocial.load();
 		await this.publicProfiles.load();
 		if (!this.limitedMode) await this.startWallets();
 		const history = /* @__PURE__ */ new Map();
-		for (const stored of await db.getLinks()) {
-			if (!stored.group) await this.settleHistory(stored.id);
-			const messages = stored.group ? [] : await db.getMessages(stored.id);
-			const storedFiles = stored.group ? [] : await fileStore.listForLink(stored.id);
+		const links = await db.getLinks();
+		for (const stored of links) history.set(stored.id, []);
+		for (const stored of links) if (stored.group) this.links.set(stored.id, newLiveLink(stored, 0, linkFilesFrom(stored.id, [], [])));
+		for (const group of await db.getGroups()) await this.settleHistory(`group:${group.id}`);
+		await this.groups.load(this.limitedMode);
+		this.groupsLoaded = true;
+		this.groupsLoadedNow();
+		this.emitState();
+		for (const stored of links) {
+			if (stored.group) continue;
+			await this.settleHistory(stored.id);
+			const messages = await db.getMessages(stored.id);
+			const storedFiles = await fileStore.listForLink(stored.id);
 			const waiting = new Set(messages.flatMap((m) => m.sender === "me" && m.delivery === "waiting" && m.file ? [m.file.id] : []));
 			for (const file of storedFiles) if (file.transfer && file.transfer.state !== "done" && !file.wire3 && !waiting.has(file.id)) this.transfers.set(file.id, file.transfer.state === "transferring" ? {
 				...file.transfer,
 				state: "failed",
 				error: "Transfer interrupted. Retry when connected."
 			} : file.transfer);
-			if (!stored.group) this.fileDesk.restore(stored.id, storedFiles);
+			this.fileDesk.restore(stored.id, storedFiles);
 			const files = linkFilesFrom(stored.id, storedFiles, messages);
 			this.links.set(stored.id, newLiveLink(stored, messages[messages.length - 1]?.timestamp ?? 0, files));
-			if (!stored.group) this.links.get(stored.id).waitingSends = Promise.resolve(new Set(messages.filter(waitsForLive).map((m) => m.id)));
+			this.links.get(stored.id).waitingSends = Promise.resolve(new Set(messages.filter(waitsForLive).map((m) => m.id)));
 			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();
+			if (stored.profile) await this.outboxFor(stored.id).recover();
 		}
 		this.transfersRestored = true;
-		for (const group of await db.getGroups()) await this.settleHistory(`group:${group.id}`);
-		await this.groups.load(this.limitedMode);
-		this.groupsLoaded = true;
 		for (const group of this.groups.views()) {
 			const note = latestReaction(await db.getMessages(`group:${group.id}`));
 			if (note) this.reactionNotes.set(`group:${group.id}`, note);
@@ -36674,14 +37802,16 @@ var GhostlyNode = class GhostlyNode {
 	/**
 	* Says goodbye on every live session (`paired-bye`): the contacts end theirs now and watch for this app to come back,
 	* instead of noticing a minute later. Synchronous: an app closing may have no time for anything after it.
+	* `quitting`: the app quits (not a page that may be reloading), so a contact's call still ringing is declined too.
 	*/
-	depart() {
-		for (const live of this.links.values()) live.link?.depart();
+	depart(options = {}) {
+		for (const live of this.links.values()) live.link?.depart(options);
 	}
 	/**
 	* Tells every peer we are leaving. Best effort: the browser may already be closing. `quiet`: says nothing to anyone
 	* (no goodbye, no departure in the links' packets), as a device another device replaced must (WISP 06 § When a
-	* device finds itself superseded: "Nothing is said to contacts and nothing more is published").
+	* device finds itself superseded: "Nothing is said to contacts and nothing more is published"). `quitting`: the app
+	* itself quits (the Desktop app, a CLI daemon), not a web page that may be reloading (`depart`).
 	*/
 	async shutdown(options = {}) {
 		const quiet = options.quiet === true || this.gatedOut;
@@ -36692,7 +37822,7 @@ var GhostlyNode = class GhostlyNode {
 			this.limitedTimer = null;
 		}
 		this.appShelf?.stop();
-		if (!quiet) this.depart();
+		if (!quiet) this.depart({ quitting: options.quitting === true });
 		const linksStopped = Promise.allSettled([...this.links.values()].map(async (live) => {
 			live.carried?.stop();
 			await Promise.all([live.link?.stop(!quiet), live.caps?.stop()]);
@@ -36726,6 +37856,8 @@ var GhostlyNode = class GhostlyNode {
 		this.restoreTimer = null;
 		this.identities.stop();
 		this.did.stop();
+		this.contactLinks.stop();
+		this.contactAsks.stop();
 		this.nostrSocial.stop();
 		this.publicProfiles.stop();
 		this.publicActivity.clear();
@@ -36763,6 +37895,7 @@ var GhostlyNode = class GhostlyNode {
 		const withdraw = Promise.allSettled([
 			this.hold.withdrawAll(),
 			this.did.deactivate(),
+			this.contactLinks.withdraw(),
 			this.identities.revokeAll()
 		]);
 		await Promise.race([withdraw, new Promise((resolve) => setTimeout(resolve, CLEAR_WITHDRAW_MS))]);
@@ -36891,6 +38024,9 @@ var GhostlyNode = class GhostlyNode {
 			payments: this.desk.views(),
 			identityProofs: this.identities.views(),
 			did: this.did.view(),
+			contactLink: this.contactLinks.view(),
+			contactRequests: this.contactLinks.requests(),
+			contactAsks: this.contactAsks.views(),
 			nostr: this.nostrSocial.state(),
 			edges: [...[...this.links.values()].filter((live) => live.stored.group && !live.stored.groupEntry).map((live) => this.viewOf(live)), ...this.communityPayViews(groups)],
 			groups: groups.map((group) => ({
@@ -37202,9 +38338,42 @@ var GhostlyNode = class GhostlyNode {
 	recheckIdentityProof(params) {
 		return this.identities.recheck(params);
 	}
+	newX401HolderKey() {
+		return this.x401.newKey();
+	}
+	addX401Credential(params) {
+		return this.x401.add(params);
+	}
+	x401Credentials(params = {}) {
+		return this.x401.list(params);
+	}
+	removeX401Credential(params) {
+		return this.x401.remove(params);
+	}
 	setDidListed(params) {
 		return this.did.setListed(params);
 	}
+	/** A new contact link for the profile; the one before is turned off. */
+	createContactLink() {
+		return this.contactLinks.create();
+	}
+	turnOffContactLink() {
+		return this.contactLinks.turnOff();
+	}
+	/** The contact link was shown or copied, or Requests opened: look for requests now and often for a while. */
+	contactLinkShown() {
+		this.contactLinks.shown();
+	}
+	acceptContactRequest({ id }) {
+		return this.contactLinks.accept(id);
+	}
+	declineContactRequest({ id }) {
+		return this.contactLinks.decline(id);
+	}
+	/** Sends a request through someone's contact link; the chat made for it. */
+	askContactLink(params) {
+		return this.contactAsks.ask(params);
+	}
 	lookupIdentityDisplay(params) {
 		const r = this.links.get(params.linkId)?.stored.identities?.received.find((x) => x.id === params.id);
 		if (r?.binding.provider === "nostr") return this.nostrSocial.loadContact({
@@ -37536,6 +38705,8 @@ var GhostlyNode = class GhostlyNode {
 	groupHistoryGone(groupId) {
 		const linkId = `group:${groupId}`;
 		this.newestAt.delete(linkId);
+		this.lateAt.delete(linkId);
+		for (const clock of this.clockLeads.keys()) if (clock.startsWith(`${linkId} `)) this.clockLeads.delete(clock);
 		this.placedAt.delete(linkId);
 		this.reactionNotes.delete(linkId);
 		this.reactionNotesBefore.delete(linkId);
@@ -37699,6 +38870,7 @@ var GhostlyNode = class GhostlyNode {
 		this.nostrSocial.forgetLink(linkId);
 		this.hold.forgetLink(linkId);
 		this.fileDesk.drop(linkId);
+		this.contactAsks.forgetChat(linkId).catch(() => {});
 		this.wakeLimiter.reset(linkId);
 		this.callWakeLimiter.reset(linkId);
 		if (live.stored.wakeToken) this.rotateWake().then(() => this.emitState());
@@ -38279,7 +39451,7 @@ var GhostlyNode = class GhostlyNode {
 		if (!queue) {
 			queue = new EditQueue({
 				read: () => db.getMessages(linkId),
-				row: (id) => db.getMessage(linkId, id),
+				rows: (ids) => db.getMessagesById(linkId, ids),
 				ready: () => {
 					const live = this.links.get(linkId), link = live?.link;
 					return !!link && (link.supportsEdits || link.textDelivery === "dht" && this.takesDhtEdits(live));
@@ -39684,7 +40856,7 @@ var GhostlyNode = class GhostlyNode {
 	* as a new message of mine, in the order they were written, carrying one more hop than it had and nothing of who wrote
 	* it or where. A text goes as written; a file from the bytes on this device (a copy per chat, nothing fetched again),
 	* through the chat's own path, so a large one still waits for the contact's consent. A group takes texts only. What one
-	* chat refuses does not stop the others: each says what it got.
+	* chat refuses does not stop the others, nor the rest of its own: each says what it got, and which of them (`sent`).
 	*/
 	async forwardMessages(params) {
 		const { linkId } = params;
@@ -39695,7 +40867,7 @@ var GhostlyNode = class GhostlyNode {
 		if (ids.length > 30) throw new Error(`Forward at most 30 messages at once`);
 		if (!targets.length) throw new Error("No chat to forward to");
 		if (targets.length > 5) throw new Error(`Forward to at most 5 chats at once`);
-		if (linkId.startsWith("group:") ? !this.membership(linkId.slice(6)) : this.links.get(linkId)?.stored.group !== void 0 || !this.links.has(linkId)) throw new Error("Chat not found");
+		if (linkId.startsWith("group:") ? !this.groups.views().some((g) => g.id === linkId.slice(6)) : this.links.get(linkId)?.stored.group !== void 0 || !this.links.has(linkId)) throw new Error("Chat not found");
 		const chosen = await Promise.all(ids.map((id) => db.getMessage(linkId, id)));
 		if (chosen.some((m) => !m)) throw new Error("That message is not in this chat");
 		const messages = chosen.sort((a, b) => a.timestamp - b.timestamp);
@@ -39710,6 +40882,7 @@ var GhostlyNode = class GhostlyNode {
 			const result = {
 				to,
 				messageIds: [],
+				sent: [],
 				error: null
 			};
 			results.push(result);
@@ -39731,11 +40904,20 @@ var GhostlyNode = class GhostlyNode {
 							text: message.text,
 							timestamp: now()
 						});
-						if (sent.error) note(sent.error);
-						else if (sent.messageId) result.messageIds.push(sent.messageId);
+						if (sent.error) {
+							note(sent.error);
+							continue;
+						}
+						if (sent.messageId) result.messageIds.push(sent.messageId);
+						result.sent.push(message.id);
 						continue;
 					}
 					if (groupId) {
+						const check = this.groups.fileCheck(groupId);
+						if (check.error) {
+							note(check.error);
+							continue;
+						}
 						const original = message.file, file = {
 							id: groupFileId(groupId, "out"),
 							name: original.name,
@@ -39759,7 +40941,10 @@ var GhostlyNode = class GhostlyNode {
 						if (sent.error) {
 							await removeStored(file.id).catch(() => {});
 							note(sent.error);
-						} else if (sent.messageId) result.messageIds.push(sent.messageId);
+							continue;
+						}
+						if (sent.messageId) result.messageIds.push(sent.messageId);
+						result.sent.push(message.id);
 						continue;
 					}
 					if (!live.link) {
@@ -39795,8 +40980,9 @@ var GhostlyNode = class GhostlyNode {
 						throw error;
 					}
 					result.messageIds.push(`me_${timestamp}`);
+					result.sent.push(message.id);
 				} catch (error) {
-					note(error instanceof Error ? error.message : String(error));
+					note(forwardError(error));
 				}
 			}
 		}
@@ -40655,12 +41841,18 @@ var GhostlyNode = class GhostlyNode {
 		const n = this.net(network);
 		return via === "cashu" ? this.wallet.quoteInvoice(invoice, n) : this.lightningCard(n, card).then((c) => c.quote(invoice));
 	}
-	/** `confirmedReal`: the person confirmed a Mainnet payment as real money; without it one is refused. */
-	async walletPayQuote({ quote, mint, note, confirmedReal }) {
+	/**
+	* `confirmedReal`: the person confirmed a Mainnet payment as real money; without it one is refused. `linkId` +
+	* `invoice`: the chat whose message held the invoice. Paid on Testnet, its contact is told (`sayInvoicePaid`): a test
+	* mint's invoice counts only on the payer's word.
+	*/
+	async walletPayQuote({ quote, mint, note, confirmedReal, linkId, invoice }) {
 		const network = WALLET_NETWORKS.find((n) => this.lightnings[n].withQuote(quote));
 		const lightning = network && this.lightnings[network].withQuote(quote);
 		assertConfirmedReal(network ?? mintNetwork(mint), confirmedReal);
-		return { paid: lightning ? await lightning.pay(quote, { note }) : await this.wallet.payQuote(quote, mint, note) };
+		const paid = lightning ? await lightning.pay(quote, { note }) : await this.wallet.payQuote(quote, mint, note);
+		if (paid && linkId && invoice && (network ?? mintNetwork(mint)) === "testnet") this.desk.sayInvoicePaid(linkId, invoice);
+		return { paid };
 	}
 	/** A Lightning address or LNURL (LUD-16, LUD-06): resolved here, in the engine, so every platform fetches the same way. */
 	lnurlResolve({ text, network }) {
@@ -40789,8 +41981,8 @@ var GhostlyNode = class GhostlyNode {
 	bitcoinRefresh(params) {
 		return this.bitcoins[this.net(params?.network)].sources.refresh();
 	}
-	walletInspectCashu({ text }) {
-		return { inspection: this.wallet.inspect(text) };
+	async walletInspectCashu({ text }) {
+		return { inspection: await this.wallet.inspect(text) };
 	}
 	async walletReceiveToken({ token }) {
 		const { amount } = await this.wallet.receiveToken(token.trim());
@@ -42333,7 +43525,8 @@ var GhostlyNode = class GhostlyNode {
 			carry: (payload) => this.groups.carrySignal(group, peer, payload),
 			open: () => !!live.link?.isDataLinkOpen,
 			look: () => live.link?.look(),
-			direct: (payload) => this.groups.directSignal(group, peer, linkId, payload)
+			direct: (payload) => this.groups.directSignal(group, peer, linkId, payload),
+			after: live.carried?.lastDated()
 		});
 		const waiting = live.carried && this.groups.takeSignal(group, peer);
 		if (waiting) live.carried.accept(waiting);
@@ -42598,6 +43791,7 @@ var GhostlyNode = class GhostlyNode {
 		} : void 0;
 		const resumed = stored.pairedPeerKey && stored.deliveryMode !== "dht" ? resumeHere(this.transportLogOf(live), this.transportsHere(), stored.peerTransports ?? live.caps?.peer?.transports) : {};
 		let dhtShown;
+		let wasTaken = false;
 		live.link = new GhostLink({
 			paymentMethods: stored.paymentMethods,
 			paymentNetworks: this.chatNetworks(stored),
@@ -42687,6 +43881,7 @@ var GhostlyNode = class GhostlyNode {
 						throw error;
 					}
 					if (!previous.pairedPeerKey) {
+						if (!live.stored.group && live.stored.deliveryMode !== "dht") this.ensureNativeEndpoints(stored.id);
 						live.caps?.update().catch(() => {});
 						live.caps?.refresh(true);
 					}
@@ -42726,6 +43921,11 @@ var GhostlyNode = class GhostlyNode {
 				onDhtDelivery: (view) => {
 					if (stored.profile && !stored.group) this.outboxes.get(linkId)?.flush().catch(() => {}).then(() => this.editQueues.get(linkId)?.flush()).catch(() => {});
 					this.observeTransport(linkId);
+					const taken = !!live.link?.takenFromUs;
+					if (taken !== wasTaken) {
+						wasTaken = taken;
+						if (!taken && live.stored.deliveryMode !== "dht" && this.keepsNativeEndpoints(linkId, live.stored)) this.ensureNativeEndpoints(linkId);
+					}
 					const shown = JSON.stringify(view);
 					if (shown !== dhtShown) {
 						dhtShown = shown;
@@ -43093,7 +44293,7 @@ var GhostlyNode = class GhostlyNode {
 	get nativeFactories() {
 		const relay = this.relaysHyperdht ? this.hyperdhtRelay : "";
 		return {
-			...relay ? { "hyperdht/1": async (seedB64) => (await import("./hyperdhtRelay-De5FT7Am.js")).createRelayedHyperEndpoint(seedB64, relay) } : {},
+			...relay ? { "hyperdht/1": async (seedB64) => (await import("./hyperdhtRelay-13aQ4KOf.js")).createRelayedHyperEndpoint(seedB64, relay) } : {},
 			...this.options.nativeTransports,
 			...this.ownIrohRelays ? { "iroh/1": (seedB64) => this.options.nativeTransports["iroh/1"](seedB64, this.settings.irohRelays?.length ? { relays: [...this.settings.irohRelays] } : {}) } : {},
 			...this.options.irohWeb ? { "iroh/1": (seedB64) => createIrohWebEndpoint(seedB64, { relays: this.irohRelays }) } : {}
@@ -43223,7 +44423,7 @@ var GhostlyNode = class GhostlyNode {
 	*/
 	async startNativeEndpoint(linkId, expected, key, factory, inUse) {
 		const live = this.links.get(linkId), link = live?.link;
-		if (this.shuttingDown || !live?.stored.profile || live.stored.deliveryMode === "dht" || !link || link !== expected) return false;
+		if (this.shuttingDown || !live?.stored.profile || live.stored.deliveryMode === "dht" || !link || link !== expected || link.takenFromUs) return false;
 		const group = !!live.stored.group;
 		if (group && !this.keepsGroupNative(live.stored)) return false;
 		if (link.availableTransports.includes(key)) return false;
@@ -43282,7 +44482,7 @@ var GhostlyNode = class GhostlyNode {
 				starting.then((late) => late.close(), () => {});
 				return false;
 			}
-			if (this.shuttingDown || live.stored.deliveryMode === "dht" || live.link !== link || !this.links.has(linkId)) {
+			if (this.shuttingDown || live.stored.deliveryMode === "dht" || live.link !== link || !this.links.has(linkId) || link.takenFromUs) {
 				await endpoint.close();
 				return false;
 			}
@@ -43463,8 +44663,9 @@ var GhostlyNode = class GhostlyNode {
 	* 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.
+	* `place`: a received row's place given already (`placeAbove`): it takes it, and the next row still goes past the last.
 	*/
-	placed(message) {
+	placed(message, place) {
 		const now = Date.now(), last = this.placedAt.get(message.linkId) ?? 0;
 		if (message.event) {
 			if (message.sender !== "peer") return message;
@@ -43479,10 +44680,10 @@ var GhostlyNode = class GhostlyNode {
 			const sentAt = claimedTime(message.timestamp);
 			message = {
 				...message,
-				timestamp: arrivalKey(now, last),
+				timestamp: place ?? arrivalKey(now, last),
 				...sentAt !== void 0 && { sentAt }
 			};
-			this.placedAt.set(message.linkId, message.timestamp);
+			if (place === void 0) this.placedAt.set(message.linkId, message.timestamp);
 		} else this.placedAt.set(message.linkId, Math.max(last, Math.min(message.timestamp, now)));
 		return message;
 	}
@@ -43504,11 +44705,32 @@ var GhostlyNode = class GhostlyNode {
 		}));
 		if (moved.length) await this.messagesChanged(linkId, moved.map((m) => m.id));
 	}
+	/**
+	* A place just above this row of its history, below the one before it: where a group member's message that comes
+	* after a later one of theirs is stored, so nothing has to move once the rest comes (WISP 400, requirement 10). At
+	* most `AUTHOR_ORDER_ROOM` below the row, so the next older page finds room above it too; none when the two rows are
+	* less than two milliseconds apart (it goes at the end, and is placed again).
+	*/
+	async placeAbove(linkId, id) {
+		const row = await db.getMessage(linkId, id);
+		if (!row) return void 0;
+		const floor = (await db.getMessagePage(linkId, {
+			limit: 1,
+			before: {
+				timestamp: row.timestamp,
+				id: row.id
+			}
+		})).messages[0]?.timestamp ?? -Infinity;
+		return row.timestamp - floor < 2 ? void 0 : Math.max(floor + 1, row.timestamp - 64);
+	}
 	async storeMessage(message) {
 		await this.storeNewMessage(message);
 	}
-	/** Stores a message; false when it was there already (or deleted here): nothing new came. */
-	async storeNewMessage(message) {
+	/**
+	* Stores a message; false when it was there already (or deleted here): nothing new came. `straight`: a group's,
+	* straight from its author (`clockSample`). `place`: as `placed`.
+	*/
+	async storeNewMessage(message, straight = false, place) {
 		const edge = this.links.get(message.linkId)?.stored;
 		if (edge?.group && edge.groupPeer && !edge.groupEntry) message = {
 			...message,
@@ -43523,7 +44745,7 @@ var GhostlyNode = class GhostlyNode {
 			id: `${message.linkId}:${message.id}`,
 			...message.sender === "peer" ? { member: pay.member } : {}
 		};
-		message = this.placed(message);
+		message = this.placed(message, place);
 		const live = this.links.get(message.linkId);
 		if (live?.stored.deletedIds?.includes(message.id)) return false;
 		message = await this.resolveReply(message);
@@ -43553,9 +44775,9 @@ var GhostlyNode = class GhostlyNode {
 		}
 		if (!await db.addMessage(message)) return false;
 		if (live && waitsForLive(message)) live.waitingSends?.then((known) => known.add(message.id), () => {});
-		this.clockSample(message);
+		this.clockSample(message, straight);
 		const newest = this.newestAt.get(message.linkId);
-		if (!message.event) this.newestAt.set(message.linkId, Math.max(newest ?? 0, writtenAt(message, this.clockLeads.get(message.linkId))));
+		if (!message.event) this.newestAt.set(message.linkId, Math.max(newest ?? 0, writtenAt(message, this.clockLeads.get(this.clockOf(message)))));
 		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;
@@ -43822,8 +45044,8 @@ var EngineServer = class {
 			this.clients.delete(client);
 		});
 	}
-	stop() {
-		return this.node.shutdown();
+	stop(options = {}) {
+		return this.node.shutdown({ quitting: options.quitting === true });
 	}
 	detach(client) {
 		this.clients.delete(client);
@@ -43848,13 +45070,13 @@ var EngineServer = class {
 			params = { on: this.onCall.size > 0 };
 		}
 		try {
-			await this.ready;
+			await (readsGroupHistory(request) ? Promise.race([this.ready, this.node.groupsRead]) : this.ready);
 			const method = this.node[request.method];
 			if (typeof method !== "function") throw new Error(`Unknown method: ${request.method}`);
 			if (this.node.limited && !LIMITED_MODE_METHODS.has(String(request.method))) throw new Error(LIMITED_MODE_ERROR);
 			response.result = await method.call(this.node, params);
 		} catch (error) {
-			response.error = error instanceof Error ? error.message : String(error);
+			response.error = errorLine(error);
 		}
 		try {
 			client.post(response);
@@ -43931,6 +45153,12 @@ var EngineServer = class {
 		for (const client of [...this.clients]) this.post(client, event);
 	}
 };
+/** Whether a call only reads a group's stored history (`GhostlyNode.groupsRead`). */
+function readsGroupHistory(request) {
+	if (request.method === "groupMessages") return true;
+	const linkId = request.params?.linkId;
+	return request.method === "messagePage" && typeof linkId === "string" && linkId.startsWith("group:");
+}
 /** A call signal's kind (`o` for an offer), read as the client reads it; checked in full before it is replayed. */
 function signalKind(signal) {
 	try {
@@ -43942,4 +45170,4 @@ function signalKind(signal) {
 //#endregion
 export { EngineServer };
 
-//# sourceMappingURL=server-C-EkLCCt.js.map
+//# sourceMappingURL=server-Cd1dLOB8.js.map