@ghostlytools/cli 1.2.3 → 1.3.0

package/dist/assets/{server-DHMXMwNn.js → server-CBCEYKMN.js}

@@ -1,23 +1,28 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { $ as parseCommunityEdit, $a as receivedTimestamp, $c as identityFromSeed, $o as HANDOFF_PAKE, $r as vapidKeysMatch, $s as verifyEnrollProof, $t as signDidDhtPacket, A as encodeCommunityLink, Aa as reactionEmoji, Ac as signTurnPacket, Ai as DHT_TEXT_CAPABILITY, Ao as webLocalFetch, Ar as FILE_LIMITS, As as readHandoffTurnFrame, B as GroupWakeLimiter, Bc as normalizeRelayUrl, Bi as identityRevocationValue, Bn as INVITE_TAKEN, Br as mayPin, C as openGroupTyping, Ca as readForwarded, Cc as classifyTurnRead, Co as DHT_POLL_INTERVALS, Cr as pickHubs, Cs as newHandoffId, D as GROUP_READ_NOTE_COMMUNITY, Da as ReactionWindow, Dc as firstDeviceSetSecret, Do as GhostlyHttpError, Dr as readLobby, Ds as readHandoffHave, E as CommunitySession, Ea as REACTION_LIMITS, Ec as TURN_MAX, Eo as presenceSeenAt, Er as readBeaconHead, Es as readHandoffDone, F as knockIdentity, Fa as pairedReplyAuthor, Fc as turnStatedVerifier, Fi as IDENTITY_REVOCATION_LABEL, Fn as findEndpoint, Fo as RTC_CONFIG, Fr as TypingSender, Fs as readSetUpdate, Gc as withRequestOptions, Gi as lastSharedWithMe, Gn as GROUP_FILE_LIMITS, Go as LEGACY_SERVICES, Gr as WAKE_CALL_INTERVAL_MS, Gs as enrollCancelReason, H as groupWakes, Hc as traceLink, Hi as newIdentityBinding, Hn as pairedMessageFrame, Hr as pinIsNewer, I as knockRecords, Ia as readReply, Ic as turnVerifierMark, In as isFederationId, Is as setAckFrame, J as frameBytes, Ja as sameButtonText, Jc as createRelayPayload, Ji as validExternalKey, Jo as HANDOFF_CANCEL, Jr as newWakeToken, Js as enrollGrantFrame, Jt as didDhtDocument, K as GROUP_READ_NOTE, Kc as PacketTooLargeError, Ki as PeerProofs, Ko as serviceIdFromName, Kr as WakeLimiter, Ks as enrollDigits, L as mergeKnocks, La as replySnippet, Lc as DEFAULT_RELAYS, Li as IdentityExchange, Ln as parseCashuRequestPayload, Lr as typingActivity, Ls as setUpdateFrame, M as decodeGroupEntryLink, Ma as readReaction, Mc as turnInstance, Mi as dialDescriptors, Mn as ENDPOINT, Mo as decodeControl, Mr as transferStalled, Ms as sealHandoffPiece, N as encodeGroupEntryLink, Na as validReactionNumber, Nc as turnKeys, Nn as cashuRequestPayload, No as encodeControl, O as communityHasFrame, Oa as nextReactionNumber, Oc as nextTurnPosition, Oo as formatLocalTarget, Or as shouldBeHub, Os as readHandoffHello, P as entryParams, Pa as wireReaction, Pc as turnName, Pn as fedimintRequestPayload, Q as carryMentions, Qa as heardTime, Qc as createIdentity, Qn as readGroupFileMeta, Qo as HANDOFF_OFFER, Qr as checkPushEndpoint, Qs as readEnrollHello, R as readKnocks, Ra as BUTTON_ID, Rc as RelayTransport, Rn as parseFedimintRequestPayload, Rs as signTombstone, S as groupTypingEpoch, Sa as forwardedAgain, Sc as TURN_SETTLE_MS, So as DirectPathWatch, Sr as newerHead, Ss as handoffVersions, St as normalizeAtprotoHandle, T as COMMUNITY_LIMITS, Ta as GROUP_REACTION_FRAME, Tc as TURN_LAST_SEQUENCE, To as RELAY_POLL_INTERVALS, Tr as readBeacon, Ts as readHandoffCancel, U as parseGroupWakeFrame, Ua as STATUS_CARD_LIMITS, Uc as budgetRetryMs, Ui as receivedIdentityStatus, Un as engineError, Uo as emptyLinkRecords, Ur as pinNumberHolds, V as groupWakeFrame, Vi as identityStatement, Vn as LIVENESS_PING_MS, Vo as parseCallSignal, Vr as nextPinNumber, W as GROUP_LIMITS, Wc as isDiscoveryBudgetError, Wi as revokesIdentity, Wn as engineText, Wo as HTTP_SERVICE_PROTO, Wr as readPin, Ws as enrollCancelFrame, Xa as arrivalKey, Xi as automaticTransport, Xn as groupFileFallback, Xo as HANDOFF_HAVE, Xr as relayRequest, Xs as enrollProofFrame, Xt as encodeDidDhtDeactivated, Ya as statusCardText, Yi as TRANSPORTS, Yo as HANDOFF_DONE, Yr as parseWakeFrame, Ys as enrollHelloFrame, Yt as didDhtFromPublicKey, Z as GROUP_EDIT_TEXT_BYTES, Za as claimedTime, Zo as HANDOFF_HELLO, Zr as wakeRequest, Zs as readEnrollGrant, Zt as encodeDidDhtPacket, _a as EDIT_BUFFER_MS, _c as newDeviceSetSecret, _n as sparkInvoiceDetails, _o as MEMBER_KEY, _r as freshHubs, _s as handoffOfferFrame, a as planAppUpdate, ac as decodeInviteCode, ai as STATUS_CARD_CAPABILITY, al as bytesEqual, as as handoffAttemptAllowed, ba as dhtEditId, bn as isPubkyKey, bo as verifyCommitSignature, br as mergeBeacon, bs as handoffRetryAfter, ca as sanitizeFileName, cc as inviteOwnership, ci as HOLD_DATED_BACK_MS, cl as toBase64Url, cn as WALLET_NETWORKS, co as readAppRevocation, cr as readGroupSignal, cs as handoffBusyFrame, d as APP_BUNDLE_LIMITS, dc as HANDOFF_CAPABILITY, di as HoldRefusedError, dl as utf8Encode, dn as formatPaymentAmount, dr as meshHubs, ds as handoffContextProof, ea as DHT_MESSAGE_TTL, ec as createDeviceInvite, ei as chatAppId, el as identityFromSeedB64, en as ETHEREUM_USDT, eo as shownTime, es as HANDOFF_PIECE_BYTES, et as mentionsMember, f as APP_BUNDLE_MAGIC, fc as deviceEchoFrame, fi as isHoldUrl, fn as validatePaymentTarget, fo as canonicalJson, fr as pickMeshHubs, fs as handoffDataFrame, ga as parseVideoMeta, gc as devicePingFrame, gn as sparkAddressKind, gr as doorHubs, gs as handoffManifestFrames, h as appViewOf, hc as deviceLinkPairing, hn as SPARK_PROVIDER, ho as GROUP_MEMBER_CAP, hr as beaconRecords, hs as handoffHelloFrame, i as checkAppBeforeRun, ia as parseImageMeta, ic as createChatInvite, ii as EDIT_CAPABILITY, il as sanitizeAvatar, in as SEPOLIA_TEST_USDT, io as appRef, is as filePartName, ja as reactionIsNewer, jc as signTurnRelease, ji as capsDescriptors, jn as decodeBolt11, jo as LIMITS, jr as transferEnded, js as readHandoffVerified, k as decodeCommunityLink, ka as queueReaction, kc as readTurnPacket, ki as CapsExchange, ko as parseLocalTarget, kr as ChatFiles, ks as readHandoffPake, l as readAppStoreSteps, la as sanitizeMime, lc as DEVICES_CAPABILITY, li as HOLD_LIMITS, ll as toZ32, ln as assertTokenUnits, lr as MESH_HUBS, ls as handoffCancelFrame, m as appDigest, ma as parseVoiceMeta, mc as deviceKeyZ32, mi as readManifest, mn as SPARK_NETWORKS, mo as readCanonicalJson, mr as beaconKeys, ms as handoffEphemeral, n as appStoreDecision, na as DHT_FILE_CAPABILITY, nc as readDeviceInvite, ni as APPS_CAPABILITY, nl as verify, nn as ONCHAIN_PROVIDER, no as APP_STATEMENT_LIMITS, nr as CarriedTransport, ns as HANDOFF_TIMINGS, o as APP_STORE_LIMITS, oa as formatFileSize, oc as encodeInviteCode, oi as UPGRADE_CAPABILITY, ol as fromBase64Url, on as TEST_USDT_FAUCET_AMOUNT, oo as isAppKey, os as handoffAttemptFailed, pa as fileMessageText, pc as deviceEchoNonce, pi as newMailbox, pn as walletNetworkOf, pr as COMMUNITY_TOPOLOGY, ps as handoffDigest, q as GroupSession, qa as checkStatusCard, qi as emptyProofLedger, qo as HANDOFF_ACK, qr as deviceWakeRequest, qs as enrollDoneFrame, r as appUpdateDecision, ra as dhtFileId, rc as OwnInviteError, ri as BUTTONS_CAPABILITY, rn as PaymentPreflightError, ro as appFingerprint, rs as HANDOFF_VERIFIED, sa as safeBlobType, si as HOLD_CAPABILITY, sl as randomBytes, sn as USDT_PUBLIC_RPC, so as isAppRef, sr as groupSignalFrame, ss as handoffAttemptSucceeded, t as appRevocationFor, ta as peekDhtMailbox, tc as deviceInviteJoinerParams, ti as isAppVersion, tl as publicKeyFromZ32, tn as EVM_TEST_CHAINS, ts as HANDOFF_REQUEST, tt as groupName, uc as ENROLL_CAPABILITY, ui as HoldKeys, ul as utf8Decode, un as assertWholeSats, ur as mayBeHub, us as handoffContext, v as isAppUrl, va as EDIT_RATE_WINDOW_MS, vc as seedSigner, vn as isBitcoinAddress, vo as commitHash, vr as lobbyKeys, vs as handoffPakeFrame, w as sealGroupTyping, wa as COMMUNITY_REACTION_FRAME, wc as turnPutSummary, wr as rankHubs, ws as readHandoffAck, x as GroupTypingBoard, xa as parseLinkPreview, xc as TURN_RAISE_READ_TIMEOUT_MS, xo as edgeParams, xr as mergeLobby, xs as handoffStreamKey, xt as isAtprotoDid, y as readAppBundle, ya as RateWindow, yc as webCryptoSigner, yo as rosterHas, yr as lobbyRecords, ys as handoffReleaseFrame, zc as currentRelays, zi as emptyIdentityLedger, zn as GhostLink, zr as PIN_LIMITS, zs as verifySetUpdate } from "./src-_FzJkeAJ.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-CTF6LF5B.js";
-import { a as fileBytesOf, c as removeFileBytes, i as fileBytes, l as FILE_BYTES_STEP, n as blobDigest } from "./fileBytes-BcYZhNgF.js";
-import { $ as BACKUP_MEDIA_TYPE, A as requireTurn, At as paymentWireId, B as networkLabel, C as breezDatabasesFor, Ct as storedGroupFiles, D as sourceKey, Dt as replyRef, E as ProviderSources, Et as receivedPairedReply, F as sealSeed, Ft as streamStored, G as BITCOIN_INVOICE_ON_TESTNET, H as cashuMint, I as unsealSeed, J as fakesLightning, K as DEFAULT_MINTS, L as ModeChanged, M as setSingleWriterGate, Mt as readStored$1, N as intentRepository, Nt as removeStored, O as awayFrom, Ot as replyTo, P as newDeviceKey, Pt as storedSize, Q as paysItsOwnInvoices, R as ModeGate, S as breezDatabaseInUse, St as groupOfFile, T as lightningPaying, Tt as pairedWireReply, V as CASHU_MINT_SOURCE, W as WALLET_TYPES, X as isWorthlessMint, Y as isTestMint, Z as mintNetwork, _ as LightningCards, _t as verifyIdentity, a as irohRelayProblem, at as reserveAdapterIds, b as normalizePhrase, bt as groupFileId, c as createFailure, ct as SourceConfigError, d as paymentNetwork, dt as networkMode, et as MAX_BACKUP_BYTES, f as paymentNetworksOf, ft as redact, g as CASHU_CARD, gt as boundedIdentityFetch, ht as setOwnDidSource, i as createIrohWebEndpoint, it as registeredOnchainProviders, j as setAwayWallets, jt as FileAppender, k as refuseAway, kt as paymentAlias, l as createTiming, lt as SourceUnreachableError, mt as resolveAtprotoDid, n as loadFedimintSdk, nt as onAdaptersChanged, o as WALLET_NAMES, ot as NothingSpentError, p as walletInstances, pt as assertPublicServer, q as TEST_MINT, r as DEFAULT_IROH_RELAYS, rt as registeredLightningProviders, s as assertConfirmedReal, st as PROVIDER_PLATFORMS, t as fedimintDatabase, tt as identityProviders, u as crossNetwork, ut as isNothingSpentError, v as cardsKey, vt as chosenResolver, w as dropBreezDatabase, wt as groupReply, x as breezDatabase, xt as groupFileText, y as isRecoveryPhrase, yt as GroupFileDesk, z as WrongNetworkError } from "../ghostly.mjs";
-import { n as traceJoin } from "./joinTrace-CO8mlhNO.js";
+import { n as traceJoin } from "./joinTrace-CjRDFy85.js";
+import { $ as appRef, D as parseVideoMeta, Ft as toBase64Url, G as claimedTime, It as toZ32, J as shownTime, K as heardTime, Lt as utf8Decode, N as STATUS_CARD_LIMITS, Nt as randomBytes, O as BUTTON_ID, Ot as bytesEqual, Q as appFingerprint, Rt as utf8Encode, T as parseVoiceMeta, U as statusCardText, V as sameButtonText, W as arrivalKey, Z as APP_STATEMENT_LIMITS, _ as safeBlobType, _t as LIMITS, at as readAppRevocation, bt as encodeControl, c as readGroupFileMeta, g as formatFileSize, ht as readCanonicalJson, it as isAppRef, jt as fromBase64Url, nt as isAppHash, o as groupFileFallback, p as parseImageMeta, pt as canonicalJson, q as receivedTimestamp, rt as isAppKey, t as GROUP_FILE_LIMITS, v as sanitizeFileName, w as fileMessageText, y as sanitizeMime, yt as decodeControl, z as checkStatusCard } from "./groupFiles-DBbjOLuD.js";
+import { $a as HANDOFF_HELLO, $i as EDIT_RATE_WINDOW_MS, $o as readEnrollGrant, $r as STATUS_CARD_CAPABILITY, $t as didDhtFromPublicKey, A as CommunitySession, Aa as RELAY_POLL_INTERVALS, Ao as readHandoffHello, Ar as typingActivity, As as nextTurnPosition, B as knockRecords, Bi as PeerProofs, Bn as isFederationId, Bo as signTombstone, Br as deviceWakeRequest, Bs as RelayTransport, C as sha256Paced, Ca as rosterHas, Ci as CapsExchange, Co as handoffStreamKey, Cr as FILE_LIMITS, Cs as TURN_RAISE_READ_TIMEOUT_MS, D as openGroupTyping, Do as readHandoffCancel, Ds as TURN_LAST_SEQUENCE, E as groupTypingEpoch, Ea as DirectPathWatch, Ei as dialDescriptors, Eo as readHandoffAck, Es as turnPutSummary, Et as normalizeAtprotoHandle, Fa as webLocalFetch, Fi as identityStatement, Fn as decodeBolt11, Fr as pinIsNewer, Fs as turnKeys, G as groupWakeFrame, Ga as emptyLinkRecords, Gn as LIVENESS_PING_MS, Gr as checkPushEndpoint, Gs as budgetRetryMs, H as readKnocks, Hi as validExternalKey, Hn as parseFedimintRequestPayload, Hr as parseWakeFrame, Hs as normalizeRelayUrl, I as decodeGroupEntryLink, Ii as newIdentityBinding, In as ENDPOINT, Ir as pinNumberHolds, Is as turnName, J as GROUP_LIMITS, Ja as serviceIdFromName, Ji as DHT_MESSAGE_TTL, Jn as engineText, Jo as enrollDigits, Jr as chatAppId, Js as PacketTooLargeError, K as groupWakes, Ka as HTTP_SERVICE_PROTO, Kn as pairedMessageFrame, Ko as enrollCancelFrame, Kr as vapidKeysMatch, Ks as isDiscoveryBudgetError, L as encodeGroupEntryLink, La as RTC_CONFIG, Li as receivedIdentityStatus, Ln as cashuRequestPayload, Lo as readSetUpdate, Lr as readPin, Ls as turnStatedVerifier, M as communityHasFrame, Ma as GhostlyHttpError, Mo as readHandoffTurnFrame, Mr as PIN_LIMITS, Ms as signTurnPacket, N as decodeCommunityLink, Na as formatLocalTarget, Ni as emptyIdentityLedger, No as readHandoffVerified, Nr as mayPin, Ns as signTurnRelease, O as sealGroupTyping, Oa as DHT_POLL_INTERVALS, Oo as readHandoffDone, Or as TypingSender, Os as TURN_MAX, P as encodeCommunityLink, Pa as parseLocalTarget, Pi as identityRevocationValue, Po as sealHandoffPiece, Pr as nextPinNumber, Ps as turnInstance, Q as frameBytes, Qa as HANDOFF_HAVE, Qi as EDIT_BUFFER_MS, Qo as enrollProofFrame, Qr as EDIT_CAPABILITY, Qt as didDhtDocument, R as entryParams, Ri as revokesIdentity, Rn as fedimintRequestPayload, Ro as setAckFrame, Rr as WAKE_CALL_INTERVAL_MS, Rs as turnVerifierMark, S as readAppBundleAsync, Sa as commitHash, Sn as isBitcoinAddress, So as handoffRetryAfter, Sr as ChatFiles, T as GroupTypingBoard, Ta as edgeParams, Ti as capsDescriptors, To as newHandoffId, Tr as transferStalled, Ts as classifyTurnRead, Tt as isAtprotoDid, Ua as parseCallSignal, Ui as TRANSPORTS, Un as GhostLink, Ur as relayRequest, V as mergeKnocks, Vi as emptyProofLedger, Vn as parseCashuRequestPayload, Vo as verifySetUpdate, Vr as newWakeToken, Vs as currentRelays, W as GroupWakeLimiter, Wi as automaticTransport, Wn as INVITE_TAKEN, Wr as wakeRequest, Ws as traceLink, X as GROUP_READ_NOTE, Xa as HANDOFF_CANCEL, Xi as DHT_FILE_CAPABILITY, Xo as enrollGrantFrame, Xr as APPS_CAPABILITY, Xs as createRelayPayload, Ya as HANDOFF_ACK, Yi as peekDhtMailbox, Yn as CarriedTransport, Yo as enrollDoneFrame, Yr as isAppVersion, Z as GroupSession, Za as HANDOFF_DONE, Zi as dhtFileId, Zo as enrollHelloFrame, Zr as BUTTONS_CAPABILITY, _a as readReply, _n as walletNetworkOf, _o as handoffHelloFrame, _r as rankHubs, _s as deviceLinkPairing, a as planAppUpdate, aa as COMMUNITY_REACTION_FRAME, ai as HoldRefusedError, an as EVM_TEST_CHAINS, ao as HANDOFF_VERIFIED, ar as pickMeshHubs, as as OwnInviteError, at as groupName, b as pacer, bn as sparkAddressKind, bo as handoffPakeFrame, br as readLobby, bs as seedSigner, ca as ReactionWindow, ci as readManifest, cn as SEPOLIA_TEST_USDT, co as handoffAttemptFailed, cr as beaconRecords, cs as encodeInviteCode, d as APP_BUNDLE_LIMITS, da as reactionEmoji, dn as USDT_PUBLIC_RPC, do as handoffCancelFrame, dr as lobbyKeys, ds as DEVICES_CAPABILITY, ea as RateWindow, ec as createIdentity, ei as UPGRADE_CAPABILITY, en as encodeDidDhtDeactivated, eo as HANDOFF_OFFER, er as groupSignalFrame, es as readEnrollHello, f as APP_BUNDLE_MAGIC, fa as reactionIsNewer, fn as WALLET_NETWORKS, fo as handoffContext, fr as lobbyRecords, fs as ENROLL_CAPABILITY, g as appViewOf, ga as pairedReplyAuthor, gn as validatePaymentTarget, go as handoffEphemeral, gr as pickHubs, gs as deviceKeyZ32, h as appDigest, ha as wireReaction, hn as formatPaymentAmount, ho as handoffDigest, hr as newerHead, hs as deviceEchoNonce, i as checkAppBeforeRun, ia as readForwarded, ic as verify, ii as HoldKeys, in as ETHEREUM_USDT, io as HANDOFF_TIMINGS, ir as meshHubs, is as readDeviceInvite, it as mentionsMember, j as GROUP_READ_NOTE_COMMUNITY, ja as presenceSeenAt, ji as IdentityExchange, jo as readHandoffPake, js as readTurnPacket, k as COMMUNITY_LIMITS, ki as IDENTITY_REVOCATION_LABEL, ko as readHandoffHave, ks as firstDeviceSetSecret, l as readAppStoreSteps, la as nextReactionNumber, lo as handoffAttemptSucceeded, lr as doorHubs, ma as validReactionNumber, mn as assertWholeSats, mo as handoffDataFrame, mr as mergeLobby, ms as deviceEchoFrame, n as appStoreDecision, na as parseLinkPreview, nc as identityFromSeedB64, ni as HOLD_DATED_BACK_MS, no as HANDOFF_PIECE_BYTES, nr as MESH_HUBS, ns as createDeviceInvite, nt as carryMentions, o as APP_STORE_LIMITS, oa as GROUP_REACTION_FRAME, oc as sanitizeAvatar, oi as isHoldUrl, on as ONCHAIN_PROVIDER, oo as filePartName, or as COMMUNITY_TOPOLOGY, os as createChatInvite, p as APP_ICON_PATH, pa as readReaction, pn as assertTokenUnits, po as handoffContextProof, pr as mergeBeacon, ps as HANDOFF_CAPABILITY, q as parseGroupWakeFrame, qa as LEGACY_SERVICES, qn as engineError, qo as enrollCancelReason, qs as withRequestOptions, r as appUpdateDecision, ra as forwardedAgain, rc as publicKeyFromZ32, ri as HOLD_LIMITS, rn as signDidDhtPacket, ro as HANDOFF_REQUEST, rr as mayBeHub, rs as deviceInviteJoinerParams, rt as parseCommunityEdit, sa as REACTION_LIMITS, si as newMailbox, sn as PaymentPreflightError, so as handoffAttemptAllowed, sr as beaconKeys, ss as decodeInviteCode, t as appRevocationFor, ta as dhtEditId, tc as identityFromSeed, ti as HOLD_CAPABILITY, tn as encodeDidDhtPacket, to as HANDOFF_PAKE, tr as readGroupSignal, ts as verifyEnrollProof, tt as GROUP_EDIT_TEXT_BYTES, ua as queueReaction, un as TEST_USDT_FAUCET_AMOUNT, uo as handoffBusyFrame, ur as freshHubs, us as inviteOwnership, va as replySnippet, vn as SPARK_NETWORKS, vo as handoffManifestFrames, vr as readBeacon, vs as devicePingFrame, wa as verifyCommitSignature, wi as DHT_TEXT_CAPABILITY, wn as isPubkyKey, wo as handoffVersions, wr as transferEnded, ws as TURN_SETTLE_MS, xa as MEMBER_KEY, xn as sparkInvoiceDetails, xo as handoffReleaseFrame, xr as shouldBeHub, xs as webCryptoSigner, y as isAppUrl, ya as GROUP_MEMBER_CAP, yn as SPARK_PROVIDER, yo as handoffOfferFrame, yr as readBeaconHead, ys as newDeviceSetSecret, z as knockIdentity, zi as lastSharedWithMe, zn as findEndpoint, zo as setUpdateFrame, zr as WakeLimiter, zs as DEFAULT_RELAYS } from "./src-DhfGgAUu.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-DxZWHw6v.js";
+import { $ as SourceConfigError, A as identityProviders, B as verifyIdentity, C as FileAppender, D as streamStored, E as storedSize, F as onAdaptersChanged, G as normalizePhrase, H as LightningCards, I as registeredLightningProviders, J as sourceKey, K as lightningPaying, L as registeredOnchainProviders, M as resolveAtprotoDid, N as setOwnDidSource, P as chosenResolver, Q as PROVIDER_PLATFORMS, R as reserveAdapterIds, S as WALLET_TYPES, T as removeStored, U as cardsKey, V as CASHU_CARD, W as isRecoveryPhrase, X as cashuMint, Y as CASHU_MINT_SOURCE, Z as NothingSpentError, _ as crossNetwork, _t as setAwayWallets, a as storedGroupFiles, at as breezDatabaseInUse, b as walletInstances, c as receivedPairedReply, ct as iceServerProblem, d as paymentAlias, dt as ModeGate, et as SourceUnreachableError, f as paymentWireId, ft as WrongNetworkError, g as createTiming, gt as requireTurn, h as createFailure, ht as refuseAway, i as groupOfFile, it as breezDatabase, j as assertPublicServer, l as replyRef, lt as iceServerSetting, m as assertConfirmedReal, mt as awayFrom, n as groupFileId, nt as networkMode, o as groupReply, ot as breezDatabasesFor, p as WALLET_NAMES, pt as networkLabel, q as ProviderSources, r as groupFileText, rt as redact, s as pairedWireReply, st as dropBreezDatabase, t as GroupFileDesk, tt as isNothingSpentError, u as replyTo, ut as ModeChanged, v as paymentNetwork, vt as setSingleWriterGate, w as readStored$1, y as paymentNetworksOf, z as boundedIdentityFetch } from "./groupFiles-BNTSDaoq.js";
+import { i as fedimintDatabase, n as createIrohWebEndpoint, o as loadFedimintSdk, r as irohRelayProblem, t as DEFAULT_IROH_RELAYS } from "./irohWeb--YyEA-hX.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 { 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-BvU0fLEt.js";
+import { t as hyperdhtRelayProblem } from "./hyperdhtRelay-BT_wRxab.js";
 import { hkdf } from "@noble/hashes/hkdf.js";
 import { sha256 } from "@noble/hashes/sha2.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 { secp256k1 } from "@noble/curves/secp256k1.js";
-import { wordlist } from "@scure/bip39/wordlists/english.js";
-import { decode, noteEncode, npubEncode } from "nostr-tools/nip19";
-import { finalizeEvent, getPublicKey, 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 { Address, OutScript, Transaction } from "@scure/btc-signer";
 import * as nip04 from "nostr-tools/nip04";
 import * as nip44 from "nostr-tools/nip44";
+import { finalizeEvent, getPublicKey, verifyEvent } from "nostr-tools/pure";
+import { decode, noteEncode, npubEncode } from "nostr-tools/nip19";
 /** Evidence older than this says nothing about the clock now. */
 var CLOCK_EVIDENCE_MS = 18e5;
 /** Sources kept of each kind: a profile has a few relays, and may have hundreds of contacts. */
@@ -180,7 +185,7 @@ async function migrateWalletNetworks(now = Date.now()) {
 //#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-D0lO2pRR.js");
+var loadUsdt = () => import("./usdt-C1Xao2xH.js");
 /** Every new profile starts with this wallet: an address to receive on, nothing to set up. */
 var DEFAULT_USDT = {
 	network: "ethereum",
@@ -529,21 +534,6 @@ var UsdtWallet = class {
 	}
 };
 //#endregion
-//#region ../browser/src/shared/ice.ts
-/**
-* What is wrong with a TURN/STUN server, or null. Browsers refuse to create any WebRTC connection when
-* one server in the list is malformed, so a bad entry here would silently cut off calls and files.
-*/
-function iceServerProblem(server) {
-	const urls = server.urls.split(/[\s,]+/).filter(Boolean);
-	if (!urls.length) return "Enter the TURN server address";
-	for (const url of urls) {
-		if (!/^(stun|turns?):[^\s/?#]+(\?transport=(udp|tcp))?$/i.test(url)) return `“${url}” is not a TURN or STUN address (turn:host:port)`;
-		if (/^turns?:/i.test(url) && (!server.username?.trim() || !server.credential?.trim())) return "A TURN server needs its username and credential";
-	}
-	return null;
-}
-//#endregion
 //#region ../browser/src/engine/paymentAdapters/backup.ts
 /**
 * Wallet database versions a backup may carry. 3 is what SDK 0.4.74-0.4.76 made (Ghostly 1.1.3 and earlier);
@@ -642,7 +632,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-B-ALutmU.js");
+var loadArkade = () => import("./arkade-D4BVJFEQ.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. */
@@ -11154,18 +11144,39 @@ var DEFAULT_APP_STORES = [{
 	url: "https://raw.githubusercontent.com/MiguelMedeiros/ghostly-store/HEAD/ghostly-store.json",
 	key: "y379ia3t1urwudj8o4w1qwmuwp1mcxyf956b5r7pqup7stce6diy"
 }];
+/**
+* The apps that come with Ghostly. A short list kept here on purpose, never "everything in the official store": an
+* 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
+* 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",
+	title: "Chess",
+	tagline: "Play chess with a contact, live in your chat"
+}];
 var APP_STORAGE_LIMITS = {
 	/** A key, in UTF-8 bytes. */
 	keyBytes: 256,
 	/** A value, as compact JSON in UTF-8 bytes. */
 	valueBytes: 65536,
 	/**
-	* Counted for each key beside its own bytes and its value's: what the row costs on the device (the app's reference,
-	* the scope and the key again, in the row's own key and in its two indexes). Without it a scope of one-byte values
-	* held 20 times its 5 MiB.
+	* Counted for each key beside its own bytes and its value's: what the row costs on the device (the app's reference and
+	* the scope, in the row's own key and in its two indexes). Without it a scope of one-byte values held 20 times its 5 MiB.
 	*/
 	rowBytes: 128,
-	/** Every key and value of one app in one scope, with `rowBytes` for each key. */
+	/**
+	* How many times a key's bytes count. The device keeps a key four times (the row's own key, its value and both
+	* indexes), three of them as UTF-16, about 10 bytes for each byte of the key: counted once, a scope of 256-byte keys
+	* took 40 to 55 MB for its 5 MiB.
+	*/
+	keyTimes: 8,
+	/** Every key and value of one app in one scope, with `rowBytes` for each key and its bytes `keyTimes` over. */
 	scopeBytes: 5242880
 };
 var APP_CHECK_TIMINGS = {
@@ -11178,22 +11189,74 @@ var APP_CHECK_TIMINGS = {
 /** Revocations are checked this long at a time before the page's thread is let go. */
 var REVOCATIONS_SLICE_MS = 10;
 /**
+* `ghostly-revoke.json` files whose result is kept, so an unchanged one is not checked again (the oldest dropped first):
+* at most this many, and of the ones whose list is held at most one file's limit of bytes in all. A publisher's file is
+* small; nine large ones beside one app's URLs, or one that changes at every check, would stay for the engine's life.
+*/
+var REVOCATION_FILES_KEPT = {
+	max: 64,
+	bytes: APP_FETCH_LIMITS.revocationsBytes
+};
+/**
 * Revocations of store indexes whose signature was checked, kept by `appRevocationId` so an index that changes around
 * them does not have each checked again (the one read longest ago dropped first): four indexes' worth, about 1 MiB.
 */
 var STORE_REVOCATIONS_KEPT = 4 * APP_STORE_LIMITS.revoked;
-/** `ghostly-revoke.json` files whose result is kept, so an unchanged one is not checked again (the oldest dropped first). */
-var REVOCATION_FILES_KEPT = 64;
 /** A fetched bundle kept for its install screen: at most this many, for this long. */
 var STAGED = {
 	max: 4,
 	ms: 6e5
 };
+/**
+* Checked bundles kept in memory: the most recently used `min`, and beyond them each one a running app used (`entry`,
+* `file`, `fileAt`) within `ms`. The engine is not told when an app closes; one not used for that long goes, and is read
+* and checked again if it still runs.
+*/
+var BUNDLES_KEPT = {
+	min: 2,
+	ms: 6e4
+};
 /** The first bytes of a bundle: magic, the manifest's length and the largest manifest. */
 var PEEK_BYTES = APP_BUNDLE_MAGIC.length + 4 + APP_BUNDLE_LIMITS.manifestBytes;
 var bundleId = (digest) => `app-${digest}`;
-/** What a row takes of its scope's 5 MiB: its key and value, and `rowBytes`. Not kept in the row, so rows from before count alike. */
-var costOf = (row) => APP_STORAGE_LIMITS.rowBytes + row.size;
+/**
+* The key of a scope's counter row (`AppScopeCount` as JSON in `value`, `size` 0): an app's key is never empty
+* (`keyOf`), and the app's own rows of a scope are `keysOf`, which leaves it out.
+*/
+var COUNT_KEY = "";
+var NO_ROWS = {
+	rows: 0,
+	keyBytes: 0,
+	size: 0
+};
+/**
+* What rows take of their scope's 5 MiB: `rowBytes` each, their keys `keyTimes` over and their values. Not kept, so a
+* count from before counts alike.
+*/
+var costOf = ({ rows, keyBytes, size }) => rows * APP_STORAGE_LIMITS.rowBytes + size + (APP_STORAGE_LIMITS.keyTimes - 1) * keyBytes;
+/** One row as a count, `sign` -1 to take it away. */
+var countOf = ({ key, size }, sign = 1) => ({
+	rows: sign,
+	keyBytes: sign * byteLength(key),
+	size: sign * size
+});
+var plus = (a, b) => ({
+	rows: a.rows + b.rows,
+	keyBytes: a.keyBytes + b.keyBytes,
+	size: a.size + b.size
+});
+function readCount(value) {
+	try {
+		const c = JSON.parse(value);
+		return [
+			c.rows,
+			c.keyBytes,
+			c.size
+		].every((n) => Number.isSafeInteger(n) && n >= 0) ? c : null;
+	} catch {
+		return null;
+	}
+}
 /**
 * A listing's URLs this client reads, in order, a jsDelivr copy first: one this client reads names a full commit, so it
 * holds exactly the version the store reviewed, where a raw `HEAD` may have moved on to one it has not (WISP 1200 §
@@ -11209,6 +11272,46 @@ function fail(code, words) {
 	throw new Error(`${code}: ${words}`);
 }
 /**
+* The key, in `STORES.settings`, of what the person did about the apps that come with Ghostly (one of
+* `PROFILE_SETTINGS_KEYS`: "Clear all data" drops it, and the profile is offered them as a new one is).
+*/
+var BUILT_IN_APPS_KEY = "appBuiltIns";
+/** The marks as kept, read with nothing taken on trust: a record that is not one is no mark. */
+function builtInMarks(kept) {
+	const removed = {};
+	const held = kept?.removed;
+	if (held && typeof held === "object") {
+		for (const [ref, at] of Object.entries(held)) if (isAppRef(ref) && typeof at === "number") removed[ref] = at;
+	}
+	return { removed };
+}
+/** Queues, on the settings store of an open transaction, a change of the built-in apps' marks. */
+function markBuiltIns(settings, change) {
+	const read = settings.get(BUILT_IN_APPS_KEY);
+	read.onsuccess = () => {
+		const marks = builtInMarks(read.result);
+		change(marks);
+		settings.put(marks, BUILT_IN_APPS_KEY);
+	};
+}
+var builtInRef = (app) => appRef(app.publisher, app.name);
+/**
+* The entries of the built-in list this profile is offered (WISP 1200 § Built-in apps): each reference once, not
+* installed (`installed`, by reference) and not removed by the person. An entry that is not a whole one (its key, its
+* name, its digest, a URL off the list of `appFetch.ts`, no title or tagline) is skipped, as a build with no bundle
+* for it would be.
+*/
+function builtInsDue(list, installed, marks) {
+	const due = /* @__PURE__ */ new Map();
+	for (const app of list) {
+		if (!isAppKey(app.publisher) || !isAppHash(app.digest) || !isAppFetchUrl(app.url) || !app.title || !app.tagline) continue;
+		const ref = builtInRef(app);
+		if (!isAppRef(ref) || due.has(ref) || installed.has(ref) || marks.removed[ref] !== void 0) continue;
+		due.set(ref, app);
+	}
+	return [...due.values()];
+}
+/**
 * Why a pasted link is not read: a github.com page that is neither a repository nor a file of one (`github-link`), so
 * the person is not told GitHub is off the list; any other host (`host`).
 */
@@ -11231,8 +11334,26 @@ function withRevocations(app, read) {
 		revocations: [...merged.values()]
 	} : app;
 }
-/** Rows of one app (`[ref]`), or of one app in one scope (`[ref, scope]`), in `STORES.appStorage`. */
+/** Rows of one app (`[ref]`), or of one app in one scope (`[ref, scope]`), in `STORES.appStorage`, counter rows included. */
 var rowsOf = (...prefix) => IDBKeyRange.bound(prefix, [...prefix, []]);
+/** The app's own rows of one scope: its counter row left out. */
+var keysOf = (ref, scope) => IDBKeyRange.bound([
+	ref,
+	scope,
+	COUNT_KEY
+], [
+	ref,
+	scope,
+	[]
+], true);
+/** A scope's counter row (`COUNT_KEY`). */
+var counterRow = (ref, scope, count) => ({
+	ref,
+	scope,
+	key: COUNT_KEY,
+	value: JSON.stringify(count),
+	size: 0
+});
 function done(tx) {
 	return new Promise((resolve, reject) => {
 		tx.oncomplete = () => resolve();
@@ -11265,8 +11386,10 @@ function peekAppManifest(bytes) {
 var Apps = class {
 	host;
 	staged = /* @__PURE__ */ new Map();
-	/** Bundles read back and checked, by digest: the one running is read once, not on every `file`. */
+	/** Bundles read back and checked, by digest, least recently used first (`BUNDLES_KEPT`): the ones running are read once, not on every `file`. */
 	verified = /* @__PURE__ */ new Map();
+	/** When a running app last used its bundle, by digest (`BUNDLES_KEPT`): an icon drawn is not a use. */
+	runUsed = /* @__PURE__ */ new Map();
 	/** Reads of a bundle under way, by digest: icons drawn at once share one read. */
 	verifying = /* @__PURE__ */ new Map();
 	/**
@@ -11274,7 +11397,7 @@ var Apps = class {
 	* page, in a chat's cards and in the composer's Apps is read without the whole bundle again.
 	*/
 	icons = /* @__PURE__ */ new Map();
-	/** Bytes used per `ref\0scope`, counted once from the rows and kept in step by the writes here. */
+	/** What each `ref\0scope` holds, read once from its counter row and kept in step by the writes here. */
 	usage = /* @__PURE__ */ new Map();
 	queues = /* @__PURE__ */ new Map();
 	timer = null;
@@ -11298,7 +11421,7 @@ var Apps = class {
 	* index listing the same is not peeked again at every check.
 	*/
 	listingMisses = /* @__PURE__ */ new Map();
-	/** `ghostly-revoke.json` files checked, by the SHA-256 of their bytes: their revocations, or null when refused. */
+	/** `ghostly-revoke.json` files checked, by the SHA-256 of their bytes: their revocations, or null when refused, and the bytes the held list counts for. */
 	revocationFiles = /* @__PURE__ */ new Map();
 	/** Revocations read in a store's index and verified, by `appRevocationId`: at most `STORE_REVOCATIONS_KEPT`. */
 	storeRevocations = /* @__PURE__ */ new Set();
@@ -11391,6 +11514,59 @@ var Apps = class {
 		if (!isAppRef(ref)) fail("bad-ref", "Not an app reference");
 		return await this.app(ref) ?? fail("not-installed", "This app is not installed");
 	}
+	/** The built-in list's entry of this reference, if it has one. */
+	builtIn(ref) {
+		return (this.host.builtIns ?? BUILT_IN_APPS).find((app) => builtInRef(app) === ref);
+	}
+	async builtInMarks() {
+		return builtInMarks(await wrap((await store(STORES$1.settings, "readonly")).get(BUILT_IN_APPS_KEY)));
+	}
+	/**
+	* The built-in apps this profile is offered (WISP 1200 § Built-in apps): shown with the installed ones, with nothing
+	* stored and nothing granted. Opening one is an install like any other, from the bundle the build carries.
+	*/
+	async builtIns() {
+		const list = this.host.builtIns ?? BUILT_IN_APPS;
+		if (!list.length || !this.host.readBuiltIn) return [];
+		const [installed, marks] = await Promise.all([this.installed(), this.builtInMarks()]);
+		return builtInsDue(list, new Set(installed.map((a) => a.ref)), marks).map((app) => ({
+			ref: builtInRef(app),
+			publisher: app.publisher,
+			name: app.name,
+			fingerprint: appFingerprint(app.publisher),
+			digest: app.digest,
+			url: app.url,
+			title: app.title,
+			tagline: app.tagline
+		}));
+	}
+	/**
+	* The bundle the build carries for a built-in app, checked as a fetched one is, and against its entry: the digest the
+	* list pins and the entry's reference. Anything else in that file is not this app, and nothing of it is kept.
+	*/
+	async bundled(app) {
+		if (!this.host.readBuiltIn) fail("not-carried", "This build does not carry this app");
+		let bytes;
+		try {
+			bytes = await this.host.readBuiltIn(app);
+		} catch {
+			fail("not-carried", "This build does not carry this app");
+		}
+		if (!(bytes instanceof Uint8Array) || bytes.length > APP_BUNDLE_LIMITS.bundleBytes) fail("not-carried", "This build does not carry this app");
+		const read = await readAppBundleAsync(bytes);
+		if (!read.ok) fail(read.reason, `This is not an app Ghostly can install${read.detail ? ` (${read.detail})` : ""}`);
+		if (read.bundle.digest !== app.digest || versionOf(read.bundle.manifest, read.bundle.digest).ref !== builtInRef(app)) fail("unlisted", "The app this build carries is not the one it names");
+		return {
+			bundle: read.bundle,
+			bytes
+		};
+	}
+	/** The built-in entry of this reference while the profile is offered it (`builtIns`), else undefined. */
+	async offered(ref) {
+		const app = this.builtIn(ref);
+		if (!app || !this.host.readBuiltIn) return void 0;
+		return builtInsDue([app], await this.app(ref) ? /* @__PURE__ */ new Set([ref]) : /* @__PURE__ */ new Set(), await this.builtInMarks())[0];
+	}
 	/**
 	* An installed app that may still run (WISP 1200 § Takedowns): a running app whose version its publisher revoked, or
 	* a store of the person's removed (unless this run was started with Run anyway), is cut off with `stopped`, whether
@@ -11543,7 +11719,7 @@ var Apps = class {
 	*/
 	async writeBundle(digest, bytes) {
 		const id = bundleId(digest);
-		const expected = toBase64Url(sha256(bytes));
+		const expected = toBase64Url(await sha256Paced(bytes));
 		let files;
 		let stored;
 		try {
@@ -11588,6 +11764,7 @@ var Apps = class {
 	}
 	async removeBundle(kind, digest) {
 		this.verified.delete(digest);
+		this.runUsed.delete(digest);
 		this.icons.delete(digest);
 		await (await fileBytesOf(kind))?.remove(bundleId(digest)).catch(() => {});
 	}
@@ -11597,18 +11774,24 @@ var Apps = class {
 		if (app?.digest !== digest && app?.pending?.digest !== digest) await this.removeBundle(kind, digest);
 	}
 	/** The installed bundle read back and checked again before it runs (WISP 1200 § Signatures: "again before it runs one"). */
-	verifiedBundle(app) {
+	verifiedBundle(app, running) {
+		if (running) this.runUsed.set(app.digest, this.now());
 		const kept = this.verified.get(app.digest);
-		if (kept) return Promise.resolve(kept);
+		if (kept) {
+			this.verified.delete(app.digest);
+			this.verified.set(app.digest, kept);
+			this.dropUnusedBundles();
+			return Promise.resolve(kept);
+		}
 		const under = this.verifying.get(app.digest);
 		if (under) return under;
 		const reading = (async () => {
 			const bytes = await this.readBundleBytes(app.bytes, app.digest);
 			if (!bytes) fail("needs-files", "This app's files are not on this device yet");
-			const read = readAppBundle(bytes);
+			const read = await readAppBundleAsync(bytes);
 			if (!read.ok || read.bundle.digest !== app.digest) fail("damaged", "This app's stored files do not match what was installed");
-			if (this.verified.size >= 2) this.verified.delete(this.verified.keys().next().value);
 			this.verified.set(app.digest, read.bundle);
+			this.dropUnusedBundles();
 			this.icons.set(app.digest, read.bundle.files.get("icon.png")?.slice() ?? null);
 			return read.bundle;
 		})().finally(() => {
@@ -11617,9 +11800,21 @@ var Apps = class {
 		this.verifying.set(app.digest, reading);
 		return reading;
 	}
+	/**
+	* Apps running at once do not push each other's bundle out, which every `file` read would then read and check again
+	* whole; one closed (or only drawn as an icon) goes once two newer ones are kept, at the next bundle read or hit.
+	*/
+	dropUnusedBundles() {
+		for (const digest of this.verified.keys()) {
+			if (this.verified.size <= BUNDLES_KEPT.min) break;
+			if (this.now() - (this.runUsed.get(digest) ?? -Infinity) < BUNDLES_KEPT.ms) continue;
+			this.verified.delete(digest);
+			this.runUsed.delete(digest);
+		}
+	}
 	async fetchBundle(url) {
 		const bytes = await this.host.fetch(url, { maxBytes: APP_BUNDLE_LIMITS.bundleBytes });
-		const read = readAppBundle(bytes);
+		const read = await readAppBundleAsync(bytes);
 		if (!read.ok) fail(read.reason, `This is not an app Ghostly can install${read.detail ? ` (${read.detail})` : ""}`);
 		return {
 			bundle: read.bundle,
@@ -11635,7 +11830,7 @@ var Apps = class {
 	*/
 	async readStoreAt(url, heldKey, held) {
 		const [indexBytes, sigBytes] = await Promise.all([this.host.fetch(url, { maxBytes: APP_FETCH_LIMITS.storeIndexBytes }), this.host.fetch(besideUrl(url, "ghostly-store.sig"), { maxBytes: APP_FETCH_LIMITS.sigBytes })]);
-		if (held?.index && held.digest !== void 0 && toBase64Url(sha256(indexBytes)) === held.digest) return {
+		if (held?.index && held.digest !== void 0 && toBase64Url(await sha256Paced(indexBytes)) === held.digest) return {
 			ok: true,
 			store: {
 				index: held.index,
@@ -11644,14 +11839,11 @@ var Apps = class {
 			}
 		};
 		const steps = readAppStoreSteps(indexBytes, sigBytes, this.nowS(), heldKey, this.checkedRevocations);
-		let since = performance.now();
+		const pause = pacer(REVOCATIONS_SLICE_MS);
 		for (;;) {
 			const step = steps.next();
 			if (step.done) return step.value;
-			if (performance.now() - since >= REVOCATIONS_SLICE_MS) {
-				await new Promise((resolve) => setTimeout(resolve, 0));
-				since = performance.now();
-			}
+			await pause();
 		}
 	}
 	/**
@@ -11675,19 +11867,16 @@ var Apps = class {
 	* engine shares the page's thread, and each entry is a signature check. The same bytes are not checked again.
 	*/
 	async readRevocationsFile(bytes) {
-		const id = toBase64Url(sha256(bytes));
+		const id = toBase64Url(await sha256Paced(bytes));
 		const known = this.revocationFiles.get(id);
-		if (known !== void 0) return known;
+		if (known !== void 0) return known.revocations;
 		const read = readCanonicalJson(bytes);
 		let out = null;
 		if (read.ok && Array.isArray(read.value) && read.value.length <= APP_STATEMENT_LIMITS.revocations) {
 			out = [];
-			let since = performance.now();
+			const pause = pacer(REVOCATIONS_SLICE_MS);
 			for (const entry of read.value) {
-				if (performance.now() - since >= REVOCATIONS_SLICE_MS) {
-					await new Promise((resolve) => setTimeout(resolve, 0));
-					since = performance.now();
-				}
+				await pause();
 				const one = readAppRevocation(entry);
 				if (!one.ok) {
 					out = null;
@@ -11697,8 +11886,17 @@ var Apps = class {
 			}
 		}
 		this.revocationFiles.delete(id);
-		this.revocationFiles.set(id, out);
-		for (const old of this.revocationFiles.keys()) if (this.revocationFiles.size > REVOCATION_FILES_KEPT) this.revocationFiles.delete(old);
+		this.revocationFiles.set(id, {
+			revocations: out,
+			bytes: out ? bytes.length : 0
+		});
+		let held = 0;
+		for (const file of this.revocationFiles.values()) held += file.bytes;
+		for (const [old, file] of this.revocationFiles) {
+			if (this.revocationFiles.size <= REVOCATION_FILES_KEPT.max && held <= REVOCATION_FILES_KEPT.bytes) break;
+			this.revocationFiles.delete(old);
+			held -= file.bytes;
+		}
 		return out;
 	}
 	summary(s) {
@@ -11876,6 +12074,12 @@ var Apps = class {
 		let urls;
 		let expect = null;
 		let fromStore;
+		if ("builtIn" in source) {
+			if (!isAppRef(source.builtIn)) fail("bad-ref", "Not an app reference");
+			const app = await this.offered(source.builtIn) ?? fail("not-offered", "This app does not come with Ghostly here");
+			const { bundle, bytes } = await this.bundled(app);
+			return this.stage(bundle, bytes, app.url, void 0, true);
+		}
 		if ("url" in source) urls = [typeof source.url === "string" && appPasteUrl(source.url, "app.ghostlyapp") || notReadable(source.url, "Apps are read only from raw.githubusercontent.com, or from cdn.jsdelivr.net at a commit, over HTTPS")];
 		else if ("store" in source) {
 			const s = await this.storeRecord(source.store);
@@ -11893,6 +12097,11 @@ var Apps = class {
 			const { ref, url, sequence, digest } = source.card;
 			if (!isAppRef(ref)) fail("bad-ref", "Not an app reference");
 			if (!isAppFetchUrl(url)) fail("host", "A card's app is read only from raw.githubusercontent.com, or from cdn.jsdelivr.net at a commit");
+			const carried = typeof digest === "string" ? await this.offered(ref) : void 0;
+			if (carried && carried.digest === digest) {
+				const held = await this.bundled(carried).catch(() => null);
+				if (held) return this.stage(held.bundle, held.bytes, carried.url, void 0, true);
+			}
 			urls = [url];
 			expect = {
 				ref,
@@ -11924,7 +12133,7 @@ var Apps = class {
 		const oldest = this.staged.values().next().value;
 		if (oldest) this.sweep = setTimeout(() => this.sweepStaged(), STAGED.ms - (this.now() - oldest.at));
 	}
-	async stage(bundle, bytes, from, fromStore) {
+	async stage(bundle, bytes, from, fromStore, carried = false) {
 		for (const [digest, s] of this.staged) if (this.now() - s.at > STAGED.ms) this.staged.delete(digest);
 		this.staged.delete(bundle.digest);
 		while (this.staged.size >= STAGED.max) this.staged.delete(this.staged.keys().next().value);
@@ -11955,7 +12164,8 @@ var Apps = class {
 			asks,
 			run: this.runStatus(version, this.storeViews(stores), installed?.revocations),
 			listedBy,
-			unknownPublisher: !listedBy.some((s) => s.kind === "curated")
+			unknownPublisher: !listedBy.some((s) => s.kind === "curated"),
+			...carried && { carried: true }
 		};
 	}
 	/**
@@ -12009,6 +12219,7 @@ var Apps = class {
 		const kind = await this.writeBundle(digest, bytes);
 		const next = this.versionRecord(installed, bundle, kind, from, fromStore);
 		await this.putApp(next);
+		if (!installed && this.builtIn(version.ref)) await this.keepBuiltIn(version.ref);
 		if (installed && installed.digest !== digest) await this.removeBundle(installed.bytes, installed.digest);
 		if (installed?.pending && next.pending?.digest !== installed.pending.digest && installed.pending.digest !== digest) await this.removeBundle(installed.pending.bytes, installed.pending.digest);
 		this.staged.delete(digest);
@@ -12047,7 +12258,7 @@ var Apps = class {
 		const installed = await this.installedOrFail(ref);
 		const pending = installed.pending ?? fail("no-update", "No update waits for this app");
 		const bytes = await this.readBundleBytes(pending.bytes, pending.digest);
-		const read = bytes ? readAppBundle(bytes) : null;
+		const read = bytes ? await readAppBundleAsync(bytes) : null;
 		if (!read?.ok || read.bundle.digest !== pending.digest) {
 			const { pending: _p, ...rest } = installed;
 			await this.putApp(rest);
@@ -12282,6 +12493,26 @@ var Apps = class {
 		const app = await this.installedOrFail(ref);
 		const stores = await this.stores();
 		if (await this.hasBundle(app.bytes, app.digest)) return this.runCheckOf(app, stores);
+		const carried = this.builtIn(app.ref);
+		if (carried && carried.digest === app.digest) {
+			const held = await this.bundled(carried).catch(() => null);
+			if (held) {
+				const kind = await this.writeBundle(app.digest, held.bytes);
+				const now = await this.app(app.ref);
+				if (!now || now.digest !== app.digest) {
+					await this.removeBundle(kind, app.digest);
+					fail("not-installed", "This app is not installed");
+				}
+				if (now.bytes !== kind) await this.putApp({
+					...now,
+					bytes: kind
+				});
+				return this.runCheckOf({
+					...now,
+					bytes: kind
+				}, stores);
+			}
+		}
 		const urls = [app.from];
 		for (const s of stores) {
 			if (app.store !== void 0 && s.key !== app.store) continue;
@@ -12289,6 +12520,14 @@ var Apps = class {
 		}
 		if (app.store === void 0) urls.push(...app.manifest.sources ?? []);
 		for (const url of new Set(urls.filter(isAppFetchUrl))) {
+			try {
+				if (peekAppManifest(await this.host.fetch(url, {
+					maxBytes: PEEK_BYTES,
+					peek: true
+				}))?.digest !== app.digest) continue;
+			} catch {
+				continue;
+			}
 			let fetched;
 			try {
 				fetched = await this.fetchBundle(url);
@@ -12336,7 +12575,7 @@ var Apps = class {
 		if (run.status === "removed" && runAnyway !== true) fail("removed", `Removed by ${run.by[0].name}: ${run.by[0].reason}`);
 		if (run.status === "needs-files") fail("needs-files", "This app's files are not on this device yet");
 		if (run.status === "removed") this.anyway.add(`${app.ref} ${app.digest}`);
-		const bundle = await this.verifiedBundle(app);
+		const bundle = await this.verifiedBundle(app, true);
 		const entry = bundle.files.get(bundle.manifest.entry) ?? fail("damaged", "The entry is missing");
 		this.ran.add(app.ref);
 		const versions = this.started.get(app.ref) ?? /* @__PURE__ */ new Map();
@@ -12351,14 +12590,40 @@ var Apps = class {
 			entry: utf8Decode(entry)
 		};
 	}
-	/** A file of the installed bundle, for the broker's `file` (`ghostly.file(path)`). `digest`: the version the frame runs. */
+	/**
+	* Where a file of the installed bundle lies in this device's file storage, for a client that hands the bytes to the
+	* app itself (Desktop: Rust reads them, checks their SHA-256 and gives them to the app's window, so they never cross
+	* the Ghostly window). The same checks as `file`; null where the bundle is not in such storage, and for the icon,
+	* which `file` answers from memory.
+	*/
+	async fileAt({ ref, path, digest }) {
+		if (path === "icon.png") return null;
+		const app = await this.runningOrFail(ref, digest);
+		if (digest !== void 0 && digest !== app.digest) fail("no-file", "No such file in this app");
+		if (app.bytes !== "native") return null;
+		const bundle = await this.verifiedBundle(app, true);
+		const file = typeof path === "string" ? bundle.files.get(path) : void 0;
+		const listed = bundle.manifest.files.find((f) => f.path === path);
+		if (!file || !listed) fail("no-file", "No such file in this app");
+		return {
+			space: fileSpace(),
+			id: bundleId(app.digest),
+			offset: file.byteOffset,
+			length: file.length,
+			sha256: listed.sha256
+		};
+	}
+	/**
+	* A file of the installed bundle, for the broker's `file` (`ghostly.file(path)`): a copy, which the broker transfers to
+	* the app as it is. `digest`: the version the frame runs.
+	*/
 	async file({ ref, path, digest }) {
 		const app = path === "icon.png" ? await this.installedOrFail(ref) : await this.runningOrFail(ref, digest);
 		if (path !== "icon.png" && digest !== void 0 && digest !== app.digest) fail("no-file", "No such file in this app");
 		const icon = path === "icon.png" ? this.icons.get(app.digest) : void 0;
 		if (icon) return icon.slice();
 		if (icon === null) fail("no-file", "No such file in this app");
-		const bundle = await this.verifiedBundle(app);
+		const bundle = await this.verifiedBundle(app, path !== APP_ICON_PATH);
 		if (typeof path !== "string" || !bundle.files.has(path)) fail("no-file", "No such file in this app");
 		return bundle.files.get(path).slice();
 	}
@@ -12389,6 +12654,7 @@ var Apps = class {
 			run: await this.runCheckOf(app, stores),
 			listedBy,
 			unknownPublisher: !listedBy.some((s) => s.kind === "curated"),
+			...this.builtIn(app.ref)?.digest === app.digest && { builtIn: true },
 			...app.pending && { pending: {
 				sequence: app.pending.sequence,
 				version: app.pending.manifest.version,
@@ -12408,23 +12674,44 @@ var Apps = class {
 	}
 	/**
 	* Uninstalls an app: its bundle (and a waiting update's), its record and its storage in every scope. The person chose
-	* it, after the offer of an export (`exportData`).
+	* it, after the offer of an export (`exportData`). A built-in app is marked removed in the same transaction, and one
+	* the person never opened is only marked: no start and no update offers it again (WISP 1200 § Built-in apps).
 	*/
 	async uninstall({ ref }) {
-		const app = await this.installedOrFail(ref);
-		const tx = (await openDb()).transaction([STORES$1.apps, STORES$1.appStorage], "readwrite");
-		tx.objectStore(STORES$1.apps).delete(app.ref);
-		tx.objectStore(STORES$1.appStorage).delete(rowsOf(app.ref));
+		if (!isAppRef(ref)) fail("bad-ref", "Not an app reference");
+		const app = await this.app(ref);
+		const builtIn = this.builtIn(ref) !== void 0;
+		if (!app && !builtIn) fail("not-installed", "This app is not installed");
+		const tx = (await openDb()).transaction([
+			STORES$1.apps,
+			STORES$1.appStorage,
+			...builtIn ? [STORES$1.settings] : []
+		], "readwrite");
+		tx.objectStore(STORES$1.apps).delete(ref);
+		tx.objectStore(STORES$1.appStorage).delete(rowsOf(ref));
+		if (builtIn) markBuiltIns(tx.objectStore(STORES$1.settings), (marks) => {
+			marks.removed[ref] ??= this.now();
+		});
 		try {
 			await done(tx);
 		} finally {
-			this.held.delete(app.ref);
+			this.held.delete(ref);
 		}
-		for (const key of [...this.usage.keys()]) if (key.startsWith(`${app.ref}\0`)) this.usage.delete(key);
-		this.started.delete(app.ref);
+		for (const key of [...this.usage.keys()]) if (key.startsWith(`${ref}\0`)) this.usage.delete(key);
+		this.started.delete(ref);
+		if (!app) return;
 		await this.removeBundle(app.bytes, app.digest);
 		if (app.pending) await this.removeBundle(app.pending.bytes, app.pending.digest);
 	}
+	/** Takes the "removed by the person" mark off a built-in app, if it has one. */
+	async keepBuiltIn(ref) {
+		if ((await this.builtInMarks()).removed[ref] === void 0) return;
+		const tx = (await openDb()).transaction(STORES$1.settings, "readwrite");
+		markBuiltIns(tx.objectStore(STORES$1.settings), (marks) => {
+			delete marks.removed[ref];
+		});
+		await done(tx);
+	}
 	scopeOf(scope) {
 		if (scope === "alone" || typeof scope === "string" && this.host.isChat(scope)) return scope;
 		fail("bad-scope", "Not a chat of this profile");
@@ -12443,13 +12730,24 @@ var Apps = class {
 		});
 		return run;
 	}
+	/**
+	* What a scope holds: its counter row, when the number of rows agrees with it (one key count, no value read). A
+	* scope without one (written before it was kept) or where it disagrees (rows written by an older client) is
+	* counted from its rows once.
+	*/
 	async usageOf(ref, scope) {
 		const id = `${ref}\0${scope}`;
-		let used = this.usage.get(id);
-		if (used === void 0) {
-			used = (await wrap((await store(STORES$1.appStorage, "readonly")).index(APP_STORAGE_SCOPE_INDEX).getAll([ref, scope]))).reduce((sum, r) => sum + costOf(r), 0);
-			this.usage.set(id, used);
-		}
+		const cached = this.usage.get(id);
+		if (cached) return cached;
+		const rows = await store(STORES$1.appStorage, "readonly");
+		const [counter, n] = await Promise.all([wrap(rows.get([
+			ref,
+			scope,
+			COUNT_KEY
+		])), wrap(rows.count(keysOf(ref, scope)))]);
+		let used = counter ? readCount(counter.value) : n ? null : NO_ROWS;
+		if (!used || used.rows !== n) used = (await wrap((await store(STORES$1.appStorage, "readonly")).getAll(keysOf(ref, scope)))).reduce((sum, r) => plus(sum, countOf(r)), NO_ROWS);
+		this.usage.set(id, used);
 		return used;
 	}
 	async storageGet({ ref, scope, key, digest }) {
@@ -12463,8 +12761,8 @@ var Apps = class {
 	}
 	/**
 	* Keeps a JSON value under a key: at most 64 KiB, and 5 MiB for every key of this app in this scope, each counted
-	* with `rowBytes`. A scope already past that (filled before a key counted `rowBytes`) still takes a write that does
-	* not grow it, so the app can make room.
+	* as `costOf` says. A scope already past that (filled under an older count) still takes a write that does not grow
+	* it, so the app can make room.
 	*/
 	async storageSet({ ref, scope, key, value, digest }) {
 		const app = await this.runningOrFail(ref, digest);
@@ -12487,20 +12785,24 @@ var Apps = class {
 				where,
 				name
 			]));
-			const next = used - (old ? costOf(old) : 0) + APP_STORAGE_LIMITS.rowBytes + size;
-			if (next > APP_STORAGE_LIMITS.scopeBytes && next > used) fail("full", "This app's storage in this chat is full (5 MiB)");
+			const next = plus(old ? plus(used, countOf(old, -1)) : used, countOf({
+				key: name,
+				size
+			}));
+			if (costOf(next) > APP_STORAGE_LIMITS.scopeBytes && costOf(next) > costOf(used)) fail("full", "This app's storage in this chat is full (5 MiB)");
 			const writing = await store(STORES$1.appStorage, "readwrite");
 			if (where !== "alone" && !this.host.isChat(where)) {
 				this.usage.delete(`${app.ref}\0${where}`);
 				fail("bad-scope", "Not a chat of this profile");
 			}
-			await wrap(writing.put({
+			writing.put({
 				ref: app.ref,
 				scope: where,
 				key: name,
 				value: text,
 				size
-			}));
+			});
+			await wrap(writing.put(counterRow(app.ref, where, next)));
 			this.usage.set(`${app.ref}\0${where}`, next);
 		});
 	}
@@ -12515,39 +12817,73 @@ var Apps = class {
 				name
 			]));
 			if (!old) return;
-			await wrap((await store(STORES$1.appStorage, "readwrite")).delete([
+			const next = plus(used, countOf(old, -1));
+			const writing = await store(STORES$1.appStorage, "readwrite");
+			writing.delete([
 				app.ref,
 				where,
 				name
-			]));
-			this.usage.set(`${app.ref}\0${where}`, used - costOf(old));
+			]);
+			await (next.rows ? wrap(writing.put(counterRow(app.ref, where, next))) : wrap(writing.delete([
+				app.ref,
+				where,
+				COUNT_KEY
+			])));
+			this.usage.set(`${app.ref}\0${where}`, next);
 		});
 	}
 	async storageKeys({ ref, scope, digest }) {
 		const app = await this.runningOrFail(ref, digest);
-		return (await wrap((await store(STORES$1.appStorage, "readonly")).getAllKeys(rowsOf(app.ref, this.scopeOf(scope))))).map((k) => k[2]);
+		return (await wrap((await store(STORES$1.appStorage, "readonly")).getAllKeys(keysOf(app.ref, this.scopeOf(scope))))).map((k) => k[2]);
 	}
 	/** An app's storage in every scope, as export files (WISP 1200 § Where installed apps live), offered before an uninstall. */
 	async exportData({ ref }) {
-		const app = await this.installedOrFail(ref);
-		const rows = await wrap((await store(STORES$1.appStorage, "readonly")).getAll(rowsOf(app.ref)));
-		const scopes = /* @__PURE__ */ new Map();
-		for (const row of rows) {
-			const out = scopes.get(row.scope) ?? {
+		return (await this.exportDataText({ ref })).map(({ app, scope, entries }) => {
+			const out = {
 				ghostlyAppData: 1,
-				app: app.ref,
-				scope: row.scope,
+				app,
+				scope,
 				entries: {}
 			};
-			Object.defineProperty(out.entries, row.key, {
-				value: JSON.parse(row.value),
+			for (const [key, json] of entries) Object.defineProperty(out.entries, key, {
+				value: JSON.parse(json),
 				enumerable: true,
 				writable: true,
 				configurable: true
 			});
-			scopes.set(row.scope, out);
+			return out;
+		});
+	}
+	/**
+	* `exportData` with each value as the JSON text it is kept as, for a file written without parsing and writing every
+	* value again. Read a scope at a time, the thread let go between them: ten chats of 5 MiB read at once held it for
+	* the whole read.
+	*/
+	async exportDataText({ ref }) {
+		const app = await this.installedOrFail(ref);
+		const scopes = [];
+		const index = (await store(STORES$1.appStorage, "readonly")).index(APP_STORAGE_SCOPE_INDEX);
+		await new Promise((resolve, reject) => {
+			const request = index.openKeyCursor(rowsOf(app.ref), "nextunique");
+			request.onerror = () => reject(request.error);
+			request.onsuccess = () => {
+				const cursor = request.result;
+				if (!cursor) return resolve();
+				scopes.push(cursor.key[1]);
+				cursor.continue();
+			};
+		});
+		const out = [];
+		for (const [i, scope] of scopes.entries()) {
+			if (i) await new Promise((resolve) => setTimeout(resolve, 0));
+			const rows = await wrap((await store(STORES$1.appStorage, "readonly")).getAll(keysOf(app.ref, scope)));
+			if (rows.length) out.push({
+				app: app.ref,
+				scope,
+				entries: rows.map((row) => [row.key, row.value])
+			});
 		}
-		return [...scopes.values()];
+		return out;
 	}
 };
 //#endregion
@@ -16672,7 +17008,7 @@ function handoffNotices(was, handoff, session) {
 * device link must offer every transport both devices run: a Linux Desktop has no WebRTC, and an Iroh relay that
 * one side cannot reach leaves HyperDHT as the only way through.
 */
-var NATIVE_RETRY_MS = 1e4;
+var NATIVE_RETRY_MS$1 = 1e4;
 var NATIVE_RETRY_MAX_MS = 12e4;
 /** How often a standby reads the turn while its screen shows (WISP 06 § When a device checks), and the jitter on it. */
 var STANDBY_TURN_EVERY_MS = 6e5;
@@ -16981,7 +17317,7 @@ var DeviceLinks = class {
 	}
 	retryNative(running) {
 		if (running.nativeRetry || this.stopped || this.running.get(running.id) !== running) return;
-		const wait = Math.min(NATIVE_RETRY_MS * 2 ** running.nativeMisses, NATIVE_RETRY_MAX_MS);
+		const wait = Math.min(NATIVE_RETRY_MS$1 * 2 ** running.nativeMisses, NATIVE_RETRY_MAX_MS);
 		running.nativeMisses++;
 		running.nativeRetry = setTimeout(() => {
 			running.nativeRetry = void 0;
@@ -19355,6 +19691,7 @@ var FileDesk = class {
 			openSource: (record) => this.openSource(linkId, record),
 			changed: (record, transferred, progress) => this.changed(linkId, record, transferred, progress),
 			room: async () => (await fileBytes()).room(),
+			...this.deps.sendData && { sendData: (id, offset, data) => this.deps.sendData(linkId, id, offset, data) },
 			writable: () => this.deps.writable?.(linkId)
 		});
 		this.chats.set(linkId, made);
@@ -19374,6 +19711,7 @@ var FileDesk = class {
 			records.push(file.wire3);
 			if (file.wire3.direction === "in") chat.local.set(file.wire3.id, file.id);
 			if (!transferEnded(file.wire3)) this.restored.add(file.id);
+			if (file.wire3.state === "done") continue;
 			this.deps.transfers.set(file.id, this.view(chat, file.wire3, file.wire3.confirmed, transferStalled(file.wire3, Date.now(), this.restored.has(file.id), Date.now())));
 		}
 		chat.files.restore(records);
@@ -19814,7 +20152,7 @@ var FileDesk = class {
 			view.room = this.deps.transfers.get(id)?.room;
 			this.room(id);
 		}
-		this.deps.transfers.set(id, view);
+		if (record.state !== "done" || this.underway.has(id) || this.deps.transfers.has(id)) this.deps.transfers.set(id, view);
 		if (!transferEnded(record)) {
 			this.underway.add(id);
 			this.ended.delete(id);
@@ -20342,6 +20680,10 @@ var Outbox = class {
 	get sameLink() {
 		return !this.stopped && this.closed === this.began;
 	}
+	/** 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);
+	}
 	/** A new message a turn could not send (the link closed under it, or the ones before it still wait): it waits too. */
 	async waitsItsTurn(message) {
 		await this.store.update(message.id, "waiting", "Waits for the messages before it to go.", {
@@ -20446,7 +20788,7 @@ var Outbox = class {
 		this.busy.add(id);
 		let again;
 		try {
-			let message = read ?? (await this.store.read()).find((m) => m.id === id);
+			let message = read ?? await this.one(id);
 			if (!message?.wireId || !message.delivery || message.delivery === "delivered") return;
 			const wait = this.waiting.get(id);
 			if (wait?.timer) {
@@ -20487,7 +20829,7 @@ var Outbox = class {
 			again = this.reopenedWhileBusy.delete(id);
 		}
 		if (again) {
-			const message = (await this.store.read()).find((m) => m.id === id);
+			const message = await this.one(id);
 			if (message) await this.again(message);
 		}
 	}
@@ -20497,7 +20839,7 @@ var Outbox = class {
 	* nothing about it is unconfirmed; it counts no attempt until it goes.
 	*/
 	async wait(id, reason) {
-		const message = (await this.store.read()).find((m) => m.id === id);
+		const message = await this.one(id);
 		if (!message || this.stopped) return;
 		await this.store.update(id, "waiting", reason, { resendUntil: message.resendUntil ?? this.now() + this.policy.windowMs });
 		this.schedule(id);
@@ -20587,7 +20929,7 @@ var Outbox = class {
 	*/
 	async attempt(id, passed) {
 		if (this.stopped || this.busy.has(id)) return true;
-		const message = (await this.store.read()).find((m) => m.id === id);
+		const message = await this.one(id);
 		if (!message || message.delivery !== "queued" && message.delivery !== "waiting" || message.via === "hold") {
 			this.forget(id);
 			return true;
@@ -20614,7 +20956,7 @@ var Outbox = class {
 	}
 	/** After a failed attempt: queued again, unless its window or its attempts are spent. */
 	async requeue(id, reason) {
-		const message = (await this.store.read()).find((m) => m.id === id);
+		const message = await this.one(id);
 		if (message && message.delivery !== "delivered") await this.queue(message, reason);
 	}
 	async queue(message, reason) {
@@ -20662,7 +21004,7 @@ var Outbox = class {
 			this.turn(async () => {
 				if (this.receipts.get(id) !== timer) return;
 				this.receipts.delete(id);
-				const message = (await this.store.read()).find((m) => m.id === id);
+				const message = await this.one(id);
 				if (message?.via === "pkarr") await this.expired(message);
 				else await this.requeue(id, "No receipt received yet.");
 			}).catch(() => {});
@@ -21349,8 +21691,9 @@ var db = {
 			tx.onerror = tx.onabort = () => reject(tx.error ?? /* @__PURE__ */ new Error("Link storage failed"));
 		});
 	},
-	async patchLink(linkId, patch) {
-		const tx = (await openDb()).transaction(STORES$1.links, "readwrite");
+	/** `relaxed`: for what a power cut may cost (a round trip, a note made again later), no disk sync of its own. */
+	async patchLink(linkId, patch, relaxed = false) {
+		const tx = (await openDb()).transaction(STORES$1.links, "readwrite", relaxed ? RELAXED : void 0);
 		const links = tx.objectStore(STORES$1.links);
 		const request = links.get(linkId);
 		request.onsuccess = () => {
@@ -21611,6 +21954,32 @@ var db = {
 		});
 		return result;
 	},
+	/**
+	* `patchMessage` on these rows of one history, all in one transaction: one disk sync for all of them. Resolves to
+	* the rows changed, in the order of `ids`.
+	*/
+	async patchMessages(linkId, ids, change) {
+		const tx = (await openDb()).transaction(STORES$1.messages, "readwrite");
+		const messages = tx.objectStore(STORES$1.messages);
+		const results = [];
+		ids.forEach((id, i) => {
+			const request = messages.get([linkId, id]);
+			request.onsuccess = () => {
+				const message = request.result;
+				const patch = message && change(message);
+				if (!patch) return;
+				messages.put(results[i] = {
+					...message,
+					...patch
+				});
+			};
+		});
+		await new Promise((resolve, reject) => {
+			tx.oncomplete = () => resolve();
+			tx.onerror = tx.onabort = () => reject(tx.error ?? /* @__PURE__ */ new Error("Message storage failed"));
+		});
+		return results.filter((row) => !!row);
+	},
 	async deleteMessage(linkId, messageId) {
 		await wrap((await store(STORES$1.messages, "readwrite")).delete([linkId, messageId]));
 	},
@@ -22013,6 +22382,202 @@ async function myPin(host, chat, messageId, remove, current, now = Date.now()) {
 	};
 }
 //#endregion
+//#region ../browser/src/engine/groupAuthorOrder.ts
+/**
+* How long a member's message may still be placed again below that member's older ones (WISP 400, requirement 10):
+* about a catch-up, whose answers end within the three minutes the app waits for the first.
+*/
+var AUTHOR_ORDER_WINDOW_MS = 18e4;
+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) {
+	return a.epoch > b.epoch || a.epoch === b.epoch && a.seq > b.seq;
+}
+/**
+* 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.
+*/
+var GroupAuthorOrder = class {
+	host;
+	linkOf;
+	missing;
+	/** Per group: the members' rows followed, in the order they are placed in the history. */
+	rows = /* @__PURE__ */ new Map();
+	/** 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();
+	constructor(host, linkOf, missing = () => false) {
+		this.host = host;
+		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) {
+		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);
+		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;
+		if (!due) this.due.set(groupId, due = /* @__PURE__ */ new Map());
+		due.set(row.sender, {
+			since: due.get(row.sender)?.since ?? row.at,
+			last: row.at
+		});
+		if (!this.missing(groupId, row.sender)) this.run(groupId, row.at);
+	}
+	/** Time passed: rows nothing more is on its way for, or that waited long enough, are placed again. */
+	tick(now) {
+		for (const groupId of this.due.keys()) this.run(groupId, now);
+	}
+	/** The group's history is gone (left or forgotten). */
+	forget(groupId) {
+		this.rows.delete(groupId);
+		this.due.delete(groupId);
+	}
+	/**
+	* One group's rows put in order, a member at a time; what comes meanwhile is put in order by the next turn, so a
+	* catch-up's frames that come together move each row once, not once per frame.
+	*/
+	async run(groupId, now) {
+		if (this.running.has(groupId)) return;
+		this.running.add(groupId);
+		try {
+			for (;;) {
+				const due = this.due.get(groupId);
+				const ready = [...due ?? []].filter(([sender, { since, last }]) => now - last >= 15e3 || now - since >= 9e4 || !this.missing(groupId, sender)).map(([sender]) => sender);
+				if (!ready.length) break;
+				for (const sender of ready) due.delete(sender);
+				if (!due.size) this.due.delete(groupId);
+				for (const sender of ready) {
+					const rows = this.rows.get(groupId) ?? [];
+					const mine = rows.filter((r) => r.sender === sender);
+					let from, below;
+					for (const r of [...mine].reverse()) {
+						if (below && after(r, below) && (!from || after(from, r))) from = r;
+						if (!below || after(below, r)) below = r;
+					}
+					if (!from) continue;
+					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;
+							break;
+						}
+						top = rows[i];
+					}
+					const followers = rows.slice(first, end).filter((r) => r.sender !== sender);
+					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)
+					}))]);
+					await this.host.placeAgain(this.linkOf(groupId), moved.map((r) => r.id)).catch(() => {});
+				}
+			}
+		} finally {
+			this.running.delete(groupId);
+		}
+	}
+};
+//#endregion
+//#region ../browser/src/engine/groupLineOrder.ts
+/**
+* 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
+* the next commit, so the line of that commit goes below it; a message under the commit's epoch or a later one was
+* written knowing it, and stays below the line. A catch-up brings the commits first (a commit opens the messages of
+* 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.
+*/
+var GroupLineOrder = class {
+	host;
+	/** Per history: the rows followed, in the order they are placed in it. */
+	rows = /* @__PURE__ */ new Map();
+	due = /* @__PURE__ */ new Set();
+	running = /* @__PURE__ */ new Set();
+	constructor(host) {
+		this.host = host;
+	}
+	/**
+	* 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.
+	*/
+	placing(linkId, row, at) {
+		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);
+		this.rows.set(linkId, rows);
+		return (stored) => {
+			const now = this.rows.get(linkId);
+			if (!stored) {
+				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);
+		};
+	}
+	/** These rows were placed again below everything (`GroupAuthorOrder`), in this order. */
+	moved(linkId, ids) {
+		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);
+	}
+	/** The group's history is gone (left or forgotten). */
+	forget(linkId) {
+		this.rows.delete(linkId);
+		this.due.delete(linkId);
+	}
+	/** 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);
+		if (this.running.has(linkId)) return;
+		this.running.add(linkId);
+		(async () => {
+			try {
+				while (this.due.delete(linkId)) {
+					const rows = this.rows.get(linkId) ?? [];
+					const order = [];
+					for (const row of rows) {
+						const above = row.line ? -1 : order.findIndex((r) => r.line && r.epoch > row.epoch);
+						if (above < 0) order.push(row);
+						else order.splice(above, 0, row);
+					}
+					let from = 0;
+					while (from < rows.length && rows[from] === order[from]) 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);
+					this.rows.set(linkId, order);
+					await this.host.placeAgain(linkId, order.slice(from).map((r) => r.id)).catch(() => {});
+				}
+			} finally {
+				this.running.delete(linkId);
+			}
+		})();
+	}
+};
+//#endregion
 //#region ../browser/src/engine/hubClocks.ts
 /**
 * A hub dates its beacon entry by its own clock, and a reader judges it by its own. A hub's time closer than this to
@@ -22266,11 +22831,14 @@ var Communities = class {
 	/** My frames an edge took, and which of them carry an edit (`frame id → editKey`). */
 	frames = new FramesTaken();
 	carriers = /* @__PURE__ */ new Map();
+	/** The lines of each history among the messages of their moment (`GroupLineOrder`). */
+	lineOrder;
 	constructor(host, store, timings = COMMUNITY_TIMINGS, random = Math.random) {
 		this.host = host;
 		this.store = store;
 		this.timings = timings;
 		this.random = random;
+		this.lineOrder = new GroupLineOrder(host);
 	}
 	/** Application frames and pair payloads handed to the engine, one after the other per group. */
 	deliveries = /* @__PURE__ */ new Map();
@@ -22287,6 +22855,16 @@ var Communities = class {
 	}
 	/** The clock: the last tick's time (the engine ticks every second), so every decision reads one clock. */
 	time = 0;
+	/**
+	* The communities this app is in, and those it is a hub of, as of the last tick: their idle looks share one
+	* community's pace (`beaconEvery`, `knockRecordsToRead`). Each community a hub held cost it about 10 requests a minute
+	* on each relay with nobody coming in: 4 of them on one relay, or 8 on two, spent the relays' budget on those looks,
+	* and the edges of some of them stayed down 10 minutes and more (CLI daemons, 2026-10-13).
+	*/
+	sharing = {
+		groups: 1,
+		hubs: 1
+	};
 	now() {
 		return this.time || Date.now();
 	}
@@ -22359,6 +22937,7 @@ var Communities = class {
 				accepted: true,
 				viaLink: true,
 				stage: this.joinStage(group),
+				since: group.joining.since,
 				...this.knockingWith.get(group.id) ? { waiting: this.knockingWith.get(group.id) } : {}
 			} : void 0;
 			if (invitation && !this.keptWhileKnocking(live)) return [{
@@ -22589,6 +23168,21 @@ var Communities = class {
 		await s.leave();
 		await this.forget(groupId);
 	}
+	/**
+	* Delete from this device: left first, as Leave does. With nothing connected to carry the request, a member's leave
+	* goes unsaid and the group goes anyway, as a private group's failed goodbye does: the others still list the device,
+	* but members who never open the app again kept it here for good. An admin with members is still refused: gone with
+	* the role, the group would have no admin.
+	*/
+	async deleteHere(groupId) {
+		try {
+			await this.leave(groupId);
+		} catch (error) {
+			const s = this.live.get(groupId)?.session;
+			if (!s || s.isAdmin && s.others.length) throw error;
+			await this.forget(groupId);
+		}
+	}
 	successor(groupId) {
 		const s = this.live.get(groupId)?.session;
 		if (!s) return void 0;
@@ -22659,6 +23253,7 @@ var Communities = class {
 		this.lastMentionAt.delete(groupId);
 		this.knockingWith.delete(groupId);
 		this.knockRead.delete(groupId);
+		this.lineOrder.forget(MESSAGE_LINK$1(groupId));
 		for (const linkId of [...this.host.edges(groupId).values(), ...this.host.entries(groupId).values()]) await this.host.closeEdge(linkId);
 		await this.store.deleteGroup(groupId);
 		await this.files?.drop(groupId);
@@ -22673,6 +23268,11 @@ 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;
+		const active = [...this.live.values()].filter((l) => l.session.status === "active");
+		this.sharing = {
+			groups: Math.max(1, active.length),
+			hubs: Math.max(1, active.filter((l) => l.hub).length)
+		};
 		for (const group of [...this.stored.values()]) {
 			const live = this.live.get(group.id);
 			if (group.joining && (this.knocking(group, live) || group.joining.check)) {
@@ -22719,7 +23319,7 @@ var Communities = class {
 			if ([...this.host.entries(groupId).values()].includes(linkId)) await this.host.closeEdge(linkId);
 		}
 		const alone = live.hub && !freshHubs(this.hubs(live), now).some((h) => h.key !== me);
-		if ((live.beaconFailedAt ? now - live.beaconFailedAt >= BEACON_RETRY_MS : now - live.lastBeaconRead >= (alone ? COMMUNITY_TOPOLOGY.beaconEveryMs : this.timings.beaconReadMs)) || live.lastBeaconRead === 0) await this.readBeacon(groupId, live, now);
+		if ((live.beaconFailedAt ? now - live.beaconFailedAt >= BEACON_RETRY_MS : now - live.lastBeaconRead >= this.beaconEvery(groupId, live, alone)) || live.lastBeaconRead === 0) await this.readBeacon(groupId, live, now);
 		if (!live.beaconKnown) {
 			await this.keepLooking(groupId, live, now);
 			await this.reconcile(groupId, live, now);
@@ -22981,11 +23581,22 @@ var Communities = class {
 		const n = live.members.size;
 		return n >= this.capacity(groupId, live, now, false) ? Math.max(n, COMMUNITY_TOPOLOGY.hubCapacity) : n;
 	}
+	/**
+	* How often the beacon is read: alone, as often as I write my entry. A member with an edge up shares one community's
+	* pace with the others it is in (`sharing`), up to that of a lone hub: an entry stays fresh three such readings. A
+	* hub does not: the door is the hubs whose entries it read lately (`doorHubs`, an entry 45 s old at most), and read
+	* slower, the door kept changing and read every knock record again each time. Nor a member with no edge up: who the
+	* hubs are is what it needs to connect.
+	*/
+	beaconEvery(groupId, live, alone) {
+		if (alone) return COMMUNITY_TOPOLOGY.beaconEveryMs;
+		return !live.hub && [...this.host.edges(groupId).values()].some((id) => this.host.linkReady(id, 2)) ? Math.min(this.timings.beaconReadMs * this.sharing.groups, COMMUNITY_TOPOLOGY.beaconEveryMs) : this.timings.beaconReadMs;
+	}
 	/** Reads the beacon; false when the reading did not happen (the relays held it back, or none answered). */
 	async readBeacon(groupId, live, now) {
 		live.lastBeaconRead = now;
 		const keys = beaconKeys(live.session.state.rv, groupId);
-		const records = await this.host.resolve(keys.identity.pubKeyZ32, true, live.hub).catch(() => void 0);
+		const records = await this.host.resolve(keys.identity.pubKeyZ32, true, this.doorBusy(groupId, live, now)).catch(() => void 0);
 		if (records === void 0) {
 			live.beaconFailedAt = now;
 			live.beaconAskedAt ||= now;
@@ -23193,7 +23804,7 @@ 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, true).catch(() => null) ?? []);
+		const entries = readLobby(keys, await this.host.resolve(keys.identity.pubKeyZ32, true, this.doorBusy(groupId, live, now)).catch(() => null) ?? []);
 		for (const { key, ts } of entries) {
 			if (now - ts > COMMUNITY_TOPOLOGY.lobbyFreshMs || key === live.session.myKey) continue;
 			if (live.session.wasRemoved(key)) {
@@ -23283,6 +23894,17 @@ var Communities = class {
 		return now - live.admittedAt < ADMITTED_QUIET_MS || [...live.pendingEntries.keys()].some((key) => down(entries.get(key))) || [...live.expect].some((key) => down(edges.get(key)));
 	}
 	/**
+	* As a hub: someone is coming in, or about to. I am letting someone in, the link was just shown, a crowd fills the
+	* bell, or members ask in my lobby (a hub just left, say). Then my reads of the bell, the beacon and my lobby go as
+	* the door's (`PkarrRequestOptions.door`): not held back while links signal. Otherwise they give way to the links
+	* that signal, my edges in my other communities first: an app that was a hub of 4 communities on one relay (8 on
+	* two) spent its relays' background share on reads that each said nobody was there, and its edges, whose signaling
+	* had what was left, stayed down 10 minutes and more in some of them (CLI daemons, 2026-10-13).
+	*/
+	doorBusy(groupId, live, now) {
+		return live.hub && (now < live.warmUntil || now < live.crowdUntil || now < live.lobbyBusyUntil || this.admitting(groupId, live, now));
+	}
+	/**
 	* 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.
@@ -23295,7 +23917,7 @@ var Communities = class {
 			return Array.from({ length: 4 }, (_, n) => n);
 		}
 		const crowd = now < live.crowdUntil;
-		const every = !door ? this.timings.otherHubKnockPollMs : busy && !crowd ? this.timings.knockBusyPollMs : now < live.warmUntil ? this.timings.knockWarmPollMs : this.timings.knockPollMs;
+		const every = !door ? this.timings.otherHubKnockPollMs : busy && !crowd ? this.timings.knockBusyPollMs : now < live.warmUntil ? this.timings.knockWarmPollMs : Math.min(this.timings.knockPollMs * this.sharing.hubs, this.timings.otherHubKnockPollMs);
 		if (now - live.lastKnockPoll < every) return [];
 		live.lastKnockPoll = now;
 		if (!door) return [live.knockCursor = (live.knockCursor + 1) % 4];
@@ -23321,9 +23943,10 @@ var Communities = class {
 		const records = this.knockRecordsToRead(live, door === s.myKey, busy, now);
 		if (!records.length) return;
 		let failed = 0;
+		const open = door === s.myKey && this.doorBusy(groupId, live, now);
 		const read = await Promise.all(records.map(async (n) => {
 			const record = knockRecord(link, n);
-			return readKnocks(record, await this.host.resolve(knockIdentity(record).pubKeyZ32, true, door === s.myKey && n === KNOCK_BELL).catch(() => {
+			return readKnocks(record, await this.host.resolve(knockIdentity(record).pubKeyZ32, true, open && n === KNOCK_BELL).catch(() => {
 				failed++;
 				return null;
 			}) ?? []);
@@ -23717,6 +24340,11 @@ var Communities = class {
 					sender: m.sender,
 					file: m.file
 				}, session.myKey) : void 0;
+				const placing = this.lineOrder.placing(MESSAGE_LINK$1(id), {
+					id: m.id,
+					epoch: m.epoch,
+					line: false
+				}, this.now());
 				const stored = await this.host.storeMessage({
 					linkId: MESSAGE_LINK$1(id),
 					id: m.id,
@@ -23731,6 +24359,7 @@ var Communities = class {
 					...m.card && { card: m.card },
 					...file && { file }
 				});
+				placing(stored !== false);
 				const came = m.sender === session.myKey ? timestamp : cameAt(timestamp, stored, arrivalNow(this.now()));
 				this.lastMessageAt.set(id, Math.max(this.lastMessageAt.get(id) ?? 0, came));
 				if (mentioned) this.lastMentionAt.set(id, Math.max(this.lastMentionAt.get(id) ?? 0, came));
@@ -23827,7 +24456,16 @@ var Communities = class {
 		else if (s.status === "active" && before !== after) {
 			const at = receivedTimestamp(top.ts, when);
 			for (const [key] of after) if (!rosterHas(before, key) && key !== s.myKey) await this.event(groupId, "joined", `${name(key)} joined`, at, top.e, key);
-			for (const [key] of before) if (!rosterHas(after, key)) await this.event(groupId, "gone", `${name(key)} is no longer a member`, at, top.e, key);
+			const left = (key) => {
+				const chain = s.state.chain;
+				for (let i = chain.length - 1; i >= 0; i--) if ((chain[i].k === "remove" || chain[i].k === "leave") && chain[i].s === key) return chain[i].k === "leave";
+				return false;
+			};
+			for (const [key] of before) {
+				if (rosterHas(after, key)) continue;
+				if (left(key)) await this.event(groupId, "left", `${name(key)} left`, at, top.e, key);
+				else await this.event(groupId, "gone", `${name(key)} is no longer a member`, at, top.e, key);
+			}
 			if (top.k === "role" && before.find(([k]) => k === top.s)?.[1] !== "admin") await this.event(groupId, "admin", `${name(top.s)} ${top.s === s.myKey ? "are" : "is"} now the admin`, at, top.e, top.s);
 			if (top.k === "rotate") await this.event(groupId, "rotated", "Keys rotated: a fresh epoch", at, top.e);
 		}
@@ -23836,16 +24474,21 @@ var Communities = class {
 	/** A line in the group's history. Its id carries its time: two lines at the same moment get distinct ones (`eventTime`). */
 	async event(groupId, event, text, timestamp, epoch, member) {
 		timestamp = eventTime(this.eventTimes, groupId, timestamp);
-		await this.host.storeMessage({
+		const id = `event:${epoch}:${event}:${member ?? ""}:${timestamp}`;
+		this.lineOrder.placing(MESSAGE_LINK$1(groupId), {
+			id,
+			epoch,
+			line: true
+		}, this.now())(await this.host.storeMessage({
 			linkId: MESSAGE_LINK$1(groupId),
-			id: `event:${epoch}:${event}:${member ?? ""}:${timestamp}`,
+			id,
 			text,
 			sender: "peer",
 			event,
 			member,
 			timestamp,
 			via: "datalink"
-		});
+		}) !== false);
 	}
 	eventTimes = /* @__PURE__ */ new Map();
 };
@@ -24853,6 +25496,11 @@ var INVITED_KEPT_MS = LEFT_KEPT_MS;
 */
 var ACCEPT_AGAIN_MS = 6e4;
 var ACCEPT_AGAINS = 5;
+/**
+* Admin side: a member let in over its chat, its edge not up, is sent its welcome again at most this often. The welcome
+* is the whole chain and the sealed secrets (megabytes, tens of ms to build); its app says its accept once a minute.
+*/
+var REWELCOME_MS = ACCEPT_AGAIN_MS / 2;
 /** Invitee side: the invitations one contact chat may have waiting here at a time. More are answered as declined. */
 var MAX_INVITATIONS_PER_CHAT = 4;
 /** What an invitation says of its group, kept as a claim within what a group can be: an epoch from 0, a roster of 1 to the most a group holds. */
@@ -24869,9 +25517,13 @@ var FAREWELL_ANSWERS = 3;
 var FAREWELL_COMMITS = 64;
 /**
 * A member whose messages were just asked of another (`Groups.askOf`) is told where I am only once that one's answer
-* has come: no message from it for this long, or `MESH_SYNC_HOLD_MAX_MS` after it was asked. Told at once, its own
+* has come: no message of it for this long, or `MESH_SYNC_HOLD_MAX_MS` after it was asked. Told at once, its own
 * answer raced the other's, which holds the same messages among everyone's in the order they were written, and a
 * member back in a group of five read each member's lines apart, the newest above older ones (WISP 902 § Catch-up).
+* A message of the answer is one written before the asking: what the member writes meanwhile is no reason to wait, so
+* the longest wait only has to cover a whole answer (the 256 messages a member keeps for the others and its own last
+* 32) at the pace of a phone with a long history, 600 ms a frame. At ten seconds, an answer of 200 messages at four a
+* second was cut at the 40th, and the others' newest lines landed above what was still coming.
 */
 var MESH_SYNC_HOLD_MS = 1500;
 /** Where a member's gossip turns start among the members it is connected to: a number of its own, from its key. */
@@ -24985,6 +25637,8 @@ var Groups = class {
 	syncHeld = /* @__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`). */
+	rewelcomed = /* @__PURE__ */ new Map();
 	lastGossip = /* @__PURE__ */ new Map();
 	/**
 	* Per mesh group, each reachable member some of whose messages never reached me (`GroupSession.lacking`): what was
@@ -25016,6 +25670,10 @@ var Groups = class {
 	communities;
 	/** My messages and edits an edge of a private group took. */
 	frames = new FramesTaken();
+	/** Each member's messages in the order that member wrote them, though catch-up answers race (WISP 400, requirement 10). */
+	authorOrder;
+	/** The lines of each history among the messages of their moment (`GroupLineOrder`). */
+	lineOrder;
 	/** Hubs of the private groups past 16 members (WISP 902 · Group Mesh § Hubs). */
 	hubs;
 	/** Groups whose edges are being reconciled because their hubs changed: one at a time. */
@@ -25042,6 +25700,16 @@ var Groups = class {
 			}
 		}, hubTimings);
 		this.typings = new GroupTypings(host);
+		this.lineOrder = new GroupLineOrder(host);
+		const placeAgain = host.placeAgain && (async (linkId, ids) => {
+			const done = host.placeAgain(linkId, ids);
+			this.lineOrder.moved(linkId, ids);
+			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.signals = new MeshSignals(host, {
 			session: (id) => this.sessions.get(id),
 			stored: (id) => this.stored.get(id),
@@ -25079,13 +25747,14 @@ var Groups = class {
 		await this.communities.load(all.filter((g) => g.community || g.joining));
 		for (const group of all.filter((g) => !g.community && !g.joining)) {
 			this.stored.set(group.id, group);
-			if (group.state) this.attach(group.state);
-			if (group.invited) this.invited.set(group.id, new Set(Object.keys(group.invited)));
 			const history = await this.store.getMessages(MESSAGE_LINK(group.id)), said = history.filter((m) => !m.event && !m.groupPay);
-			this.framesKept.set(group.id, history.filter((m) => m.frame).map((m) => ({
+			const framed = history.filter((m) => m.frame);
+			this.framesKept.set(group.id, framed.map((m) => ({
 				id: m.id,
 				bytes: frameBytes(m.frame)
 			})));
+			if (group.state) this.attach(group.state, framed.map((m) => m.frame));
+			if (group.invited) this.invited.set(group.id, new Set(Object.keys(group.invited)));
 			const last = said[said.length - 1], lastPeer = [...said].reverse().find((m) => m.sender !== "me");
 			if (last) this.lastMessageAt.set(group.id, last.timestamp);
 			const peerAt = cameOrWritten(lastPeer?.timestamp, lastPeer ? group.came?.peer : void 0);
@@ -25162,6 +25831,7 @@ var Groups = class {
 						members: Math.min(Math.max(invitation.n, 0), GROUP_MEMBER_CAP.max),
 						accepted: !!invitation.seedB64,
 						...this.acceptSaid.get(group.id)?.unanswered ? { unanswered: true } : {},
+						...invitation.takenBack ? { takenBack: true } : {},
 						...invitation.entry ? {
 							viaLink: true,
 							stage: this.joinStage(group)
@@ -25343,6 +26013,7 @@ var Groups = class {
 	async accept(groupId) {
 		const group = this.stored.get(groupId);
 		if (!group?.invitation) throw new Error("No invitation to accept");
+		if (group.invitation.takenBack) throw new Error("This invitation was taken back");
 		if (!this.host.linkReady(group.invitation.linkId)) throw new Error("The contact who invited you is not connected. Try again when they are.");
 		const seedB64 = group.invitation.seedB64 ?? createIdentity().seedB64;
 		group.invitation = {
@@ -25366,6 +26037,7 @@ var Groups = class {
 		if (this.isCommunity(groupId)) return this.communities.decline(groupId);
 		const group = this.stored.get(groupId);
 		if (!group?.invitation) throw new Error("No invitation to decline");
+		if (group.invitation.takenBack) return this.forget(groupId, false);
 		if (!group.previous) return this.forget(groupId);
 		await this.dropInvitation(group, this.sayDecline(groupId, group.invitation.linkId));
 	}
@@ -25381,6 +26053,25 @@ var Groups = class {
 		await this.store.putGroup(previous);
 		this.host.emit();
 	}
+	/**
+	* Invitee side: who sent the invitation took it back. A group I kept under its id comes back as it was; otherwise the
+	* invitation stays a week, marked, so the list says it was taken back where it was (an accept said for it stops).
+	*/
+	async takeBackFrom(group) {
+		if (group.previous) return this.dropInvitation(group);
+		if (group.invitation.takenBack) return;
+		const { seedB64: _unused, ...invitation } = group.invitation;
+		group.invitation = {
+			...invitation,
+			pieces: [],
+			takenBack: this.now()
+		};
+		this.acceptSaid.delete(group.id);
+		await this.store.putGroup(group);
+		const kept = [...this.stored.values()].filter((x) => x.invitation?.takenBack && !x.state && x.invitation.linkId === invitation.linkId).reverse().sort((a, b) => b.invitation.takenBack - a.invitation.takenBack);
+		for (const old of kept.slice(MAX_INVITATIONS_PER_CHAT)) await this.forget(old.id, false);
+		this.host.emit();
+	}
 	/** Invitee side: says no to an invitation. With the inviter's chat down (its app is closed, say), returns the answer owed, said when that chat is next up. */
 	sayDecline(groupId, linkId) {
 		try {
@@ -25573,6 +26264,8 @@ var Groups = class {
 		this.lastMessageAt.delete(groupId);
 		this.lastPeerMessageAt.delete(groupId);
 		this.lastMentionAt.delete(groupId);
+		this.authorOrder.forget(groupId);
+		this.lineOrder.forget(MESSAGE_LINK(groupId));
 		await this.store.deleteGroup(groupId);
 		await this.store.putGroup(group);
 		await this.files?.drop(groupId);
@@ -25766,19 +26459,20 @@ var Groups = class {
 	}
 	/** `answer`: false when an invitation goes because its inviter took it back, so no decline is said for it. */
 	async forget(groupId, answer = true) {
-		if (this.isCommunity(groupId)) return this.communities.leave(groupId);
+		if (this.isCommunity(groupId)) return this.communities.deleteHere(groupId);
 		const session = this.sessions.get(groupId);
 		if (session?.status === "active") try {
 			await this.leave(groupId);
 		} catch (e) {
 			if (session.isAdmin && session.others.length) throw e;
 		}
-		const gone = this.stored.get(groupId), invitation = answer && gone?.invitation && !gone.invitation.entry ? gone.invitation : void 0;
+		const gone = this.stored.get(groupId), invitation = answer && gone?.invitation && !gone.invitation.entry && !gone.invitation.takenBack ? gone.invitation : void 0;
 		const owed = invitation && this.sayDecline(groupId, invitation.linkId);
 		this.sessions.delete(groupId);
 		this.stored.delete(groupId);
 		this.takeBack(groupId);
 		this.acceptSaid.delete(groupId);
+		this.entryHosts.delete(groupId);
 		this.lastRoster.delete(groupId);
 		this.lastTold.delete(groupId);
 		this.pendingEntries.delete(groupId);
@@ -25792,6 +26486,7 @@ var Groups = class {
 		this.relayAsked.delete(groupId);
 		this.syncHeld.delete(groupId);
 		this.lastHanded.delete(groupId);
+		this.rewelcomed.delete(groupId);
 		this.hubs.forget(groupId);
 		this.removedAt.delete(groupId);
 		this.lastGossip.delete(groupId);
@@ -25804,6 +26499,8 @@ var Groups = class {
 		this.hereHeard.delete(groupId);
 		this.hereActed.delete(groupId);
 		this.signals.forget(groupId);
+		this.authorOrder.forget(groupId);
+		this.lineOrder.forget(MESSAGE_LINK(groupId));
 		for (const linkId of [...this.host.edges(groupId).values(), ...this.host.entries(groupId).values()]) await this.host.closeEdge(linkId);
 		await this.store.deleteGroup(groupId);
 		if (owed && !this.stored.has(groupId)) {
@@ -25902,6 +26599,7 @@ var Groups = class {
 		if (this.ticking) return;
 		this.ticking = true;
 		try {
+			this.authorOrder.tick(now);
 			for (const group of [...this.stored.values()]) {
 				if (group.left) {
 					if (now - group.left.at > LEFT_KEPT_MS) await this.forget(group.id);
@@ -25911,6 +26609,10 @@ var Groups = class {
 					await this.declineOwed(group, now);
 					if (!group.state) continue;
 				}
+				if (group.invitation?.takenBack && !group.state) {
+					if (now - group.invitation.takenBack > LEFT_KEPT_MS) await this.forget(group.id, false);
+					continue;
+				}
 				if (group.invitation?.entry && !group.state) {
 					const every = now - group.createdAt > this.timings.patienceMs ? this.timings.slowKnockMs : this.timings.knockMs;
 					if (!(this.host.linkReady(group.invitation.linkId) || !!this.host.linkSeen?.(group.invitation.linkId)) && (now - (this.lastKnock.get(group.id) ?? 0) >= every || now >= (this.knockCheckAt.get(group.id) ?? Infinity))) await this.knock(group, now).catch(() => {});
@@ -26005,6 +26707,7 @@ var Groups = class {
 			this.host.emit();
 		}
 		if (said.n >= ACCEPT_AGAINS || !said.down && now - said.at < ACCEPT_AGAIN_MS) return;
+		invitation.pieces = [];
 		try {
 			this.host.sendOnLink(invitation.linkId, {
 				t: "group-accept",
@@ -26028,7 +26731,7 @@ var Groups = class {
 		}
 		const session = this.sessions.get(groupId), group = this.stored.get(groupId);
 		if (!session?.isAdmin || !group || !this.pendingEntries.get(groupId)?.has(peer)) return;
-		if (this.growthBlocked(group, session, session.roster.length + 1, linkId)) {
+		if (!rosterHas(session.roster, peer) && this.growthBlocked(group, session, session.roster.length + 1, linkId)) {
 			this.pendingEntries.get(groupId)?.delete(peer);
 			this.refused.set(peer, Date.now() + REFUSED_FOR_MS);
 			this.host.closeEdge(linkId);
@@ -26075,14 +26778,22 @@ var Groups = class {
 		return this.knocked.has(group.id) ? "knocked" : "knocking";
 	}
 	entryOf(group) {
-		return group.entry ? {
+		if (!group.entry) return void 0;
+		const { seedB64 } = group.entry;
+		let host = this.entryHosts.get(group.id);
+		if (host?.seedB64 !== seedB64) this.entryHosts.set(group.id, host = {
+			seedB64,
+			key: identityFromSeedB64(seedB64).pubKeyZ32
+		});
+		return {
 			link: {
 				g: group.id,
-				host: identityFromSeedB64(group.entry.seedB64).pubKeyZ32
+				host: host.key
 			},
-			seedB64: group.entry.seedB64
-		} : void 0;
+			seedB64
+		};
 	}
+	entryHosts = /* @__PURE__ */ new Map();
 	/** Joiner side: the entry session kept after the welcome goes (the edge to the admin is up, or it was kept long enough). */
 	async endLinger(groupId) {
 		const kept = this.lingering.get(groupId);
@@ -26147,11 +26858,13 @@ var Groups = class {
 		});
 		let pending = this.pendingEntries.get(group.id);
 		for (const { key, ts } of knocks) {
-			if (now - ts > 18e4 || rosterHas(session.roster, key) || this.refused.has(key) || pending?.has(key) || key === entry.link.host) continue;
+			const again = this.unwelcomed(group, session, key);
+			if (now - ts > 18e4 || rosterHas(session.roster, key) && !again || this.refused.has(key) || pending?.has(key) || key === entry.link.host) continue;
+			if (again && this.rewelcomedLately(group.id, key)) continue;
 			const entryIds = new Set(this.host.entries(group.id).values());
 			const contactsInvited = [...this.invited.get(group.id) ?? []].filter((id) => !entryIds.has(id)).length;
 			const size = session.roster.length + contactsInvited + (pending?.size ?? 0);
-			if ((pending?.size ?? 0) >= MAX_PENDING_ENTRIES || size >= GROUP_MEMBER_CAP.max || this.growthBlocked(group, session, size + 1)) break;
+			if ((pending?.size ?? 0) >= MAX_PENDING_ENTRIES || !again && (size >= GROUP_MEMBER_CAP.max || this.growthBlocked(group, session, size + 1))) break;
 			if (!pending) this.pendingEntries.set(group.id, pending = /* @__PURE__ */ new Map());
 			pending.set(key, now);
 			this.warmUntil.set(group.id, now + this.timings.warmMs);
@@ -26211,9 +26924,9 @@ var Groups = class {
 				}
 				if (existing?.invitation?.seedB64 && (existing.invitation.linkId !== linkId || existing.invitation.admin !== frame.admin)) return;
 				if (existing?.left && (existing.left.admin !== frame.admin || existing.contacts?.[existing.left.admin] !== linkId)) return;
-				if (existing?.invitation && !existing.state && existing.invitation.linkId !== linkId && !existing.invitation.genesis) return;
-				if ([...this.stored.values()].filter((x) => x.invitation).length >= 32) return;
-				if (!existing?.invitation && [...this.stored.values()].filter((x) => x.invitation?.linkId === linkId).length >= MAX_INVITATIONS_PER_CHAT) {
+				if (existing?.invitation && !existing.state && existing.invitation.linkId !== linkId && !existing.invitation.genesis && !existing.invitation.takenBack) return;
+				if ([...this.stored.values()].filter((x) => x.invitation && !x.invitation.takenBack).length >= 32) return;
+				if (!existing?.invitation && [...this.stored.values()].filter((x) => x.invitation?.linkId === linkId && !x.invitation.takenBack).length >= MAX_INVITATIONS_PER_CHAT) {
 					try {
 						this.host.sendOnLink(linkId, {
 							t: "group-decline",
@@ -26256,27 +26969,54 @@ var Groups = class {
 				const session = this.sessions.get(g);
 				if (typeof frame.key !== "string" || !MEMBER_KEY.test(frame.key)) return;
 				if (!session?.isAdmin || !this.invited.get(g)?.has(linkId)) {
-					if (!(!!session && rosterHas(session.roster, frame.key) && this.stored.get(g)?.contacts?.[frame.key] === linkId) && ![...this.host.entries(g).values()].includes(linkId)) try {
+					const letIn = !!session && rosterHas(session.roster, frame.key) && this.stored.get(g)?.contacts?.[frame.key] === linkId;
+					if (!letIn && ![...this.host.entries(g).values()].includes(linkId)) try {
 						this.host.sendOnLink(linkId, {
 							t: "group-decline",
 							g
 						});
 					} catch {}
+					const edge = this.host.edges(g).get(frame.key);
+					if (letIn && session.isAdmin && !(edge && this.host.linkReady(edge))) {
+						if (this.rewelcomedLately(g, frame.key)) return;
+						this.noteRewelcome(g, frame.key);
+						const welcome = await session.rewelcome(frame.key).catch(() => []);
+						try {
+							for (const piece of welcome) this.host.sendOnLink(linkId, piece);
+						} catch {}
+					}
 					return;
 				}
 				const group = this.stored.get(g);
-				if (frame.key === session.myKey || rosterHas(session.roster, frame.key)) return;
+				if (frame.key === session.myKey) return;
 				const entryPeer = this.hostEntry(g, linkId);
 				if ([...this.host.entries(g).values()].includes(linkId) && entryPeer !== frame.key) return;
-				if (session.roster.length >= GROUP_MEMBER_CAP.max || this.growthBlocked(group, session, session.roster.length + 1, linkId)) return;
+				const again = !!entryPeer && this.unwelcomed(group, session, frame.key);
+				if (rosterHas(session.roster, frame.key) && !again) return;
+				if (again && this.rewelcomedLately(g, frame.key)) {
+					this.pendingEntries.get(g)?.delete(frame.key);
+					await this.host.closeEdge(linkId);
+					return;
+				}
+				if (again) this.noteRewelcome(g, frame.key);
+				if (!again && (session.roster.length >= GROUP_MEMBER_CAP.max || this.growthBlocked(group, session, session.roster.length + 1, linkId))) return;
 				if (!entryPeer) await session.setNick(frame.key, this.host.contactName(linkId));
-				this.meet(g, frame.key);
+				if (!again) this.meet(g, frame.key);
 				if (this.host.linkReady(linkId, 3)) this.markLarge(group, frame.key);
-				const welcome = await session.admit(frame.key);
+				let welcome;
+				try {
+					welcome = again ? await session.rewelcome(frame.key) : await session.admit(frame.key);
+				} catch (error) {
+					if (!again) throw error;
+					this.pendingEntries.get(g)?.delete(frame.key);
+					await this.host.closeEdge(linkId);
+					return;
+				}
 				if (!entryPeer) group.contacts = {
 					...group.contacts,
 					[frame.key]: linkId
 				};
+				if (!again) group.unseen = [...(group.unseen ?? []).filter((key) => rosterHas(session.roster, key)), frame.key];
 				this.answered(group, linkId);
 				await this.store.putGroup(group);
 				for (const piece of welcome) this.host.sendOnLink(linkId, piece);
@@ -26299,7 +27039,7 @@ var Groups = class {
 			case "group-decline": {
 				const mine = this.stored.get(g);
 				if (mine?.invitation && !mine.invitation.entry && !mine.state && mine.invitation.linkId === linkId) {
-					await this.dropInvitation(mine);
+					await this.takeBackFrom(mine);
 					return;
 				}
 				const entryPeer = this.hostEntry(g, linkId);
@@ -26308,6 +27048,7 @@ var Groups = class {
 					await this.host.closeEdge(linkId);
 				}
 				const group = this.stored.get(g);
+				if (group && await this.declinedUnseen(g, group, linkId)) return;
 				if (!group || !this.answered(group, linkId)) return;
 				await this.store.putGroup(group);
 				this.host.emit();
@@ -26403,7 +27144,7 @@ var Groups = class {
 				const group = this.stored.get(g);
 				const member = Object.entries(group?.contacts ?? {}).find(([, id]) => id === linkId)?.[0];
 				if (!session?.isAdmin || !member || member === session.myKey) return;
-				if (rosterHas(session.roster, member)) await session.remove(member).catch(() => {});
+				if (rosterHas(session.roster, member)) await session.remove(member, Date.now(), { left: true }).catch(() => {});
 				try {
 					this.host.sendOnLink(linkId, {
 						t: "group-removed",
@@ -26471,7 +27212,8 @@ var Groups = class {
 			return;
 		}
 		const taken = await session.handle(peerKey, frame);
-		if (taken.some((f) => f.t === "group-msg")) {
+		const askedAt = this.askedAt(groupId, peerKey);
+		if (taken.some((f) => f.t === "group-msg" && f.ts < askedAt)) {
 			let handed = this.lastHanded.get(groupId);
 			if (!handed) this.lastHanded.set(groupId, handed = /* @__PURE__ */ new Map());
 			handed.set(peerKey, this.now());
@@ -26544,9 +27286,14 @@ var Groups = class {
 			return;
 		}
 		if (!session || !group || session.status !== "active" || !rosterHas(session.roster, peerKey)) return;
+		const seen = !!group.unseen?.includes(peerKey);
+		if (seen) {
+			const unseen = group.unseen.filter((key) => key !== peerKey);
+			group.unseen = unseen.length ? unseen : void 0;
+		}
 		const large = this.host.linkReady(linkId, 3) && this.markLarge(group, peerKey);
 		const legacy = this.hubs.enabled && this.hubs.edgeReady(groupId, session, group, peerKey, this.host.linkReady(linkId, 4), this.now());
-		if (large || legacy) this.store.putGroup(group).catch(() => {});
+		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)));
 		} catch {
@@ -26569,6 +27316,41 @@ var Groups = class {
 		this.host.edgeUp?.(groupId, peerKey);
 		this.host.emit();
 	}
+	/**
+	* Admin side: a `group-decline` over the contact chat that let in a member never seen on an edge since. Its welcome
+	* was lost and its app declined the invitation it still showed: it never had the group's keys, so it goes from the
+	* roster (and may be invited again). True when one went.
+	*/
+	async declinedUnseen(groupId, group, linkId) {
+		const session = this.sessions.get(groupId);
+		if (!session?.isAdmin || session.status !== "active" || !group.unseen) return false;
+		const key = group.unseen.find((k) => group.contacts?.[k] === linkId && rosterHas(session.roster, k));
+		if (!key) return false;
+		const edge = this.host.edges(groupId).get(key);
+		if (edge && this.host.linkReady(edge)) return false;
+		const unseen = group.unseen.filter((k) => k !== key);
+		group.unseen = unseen.length ? unseen : void 0;
+		await this.remove(groupId, key).catch(() => {});
+		await this.store.putGroup(group);
+		this.host.emit();
+		return true;
+	}
+	/** Admin side: a member in the roster never seen on an edge since it was let in, whose edge is not up now. */
+	/** This member was sent its welcome again less than `REWELCOME_MS` ago, over its chat or through the link. */
+	rewelcomedLately(groupId, key) {
+		const last = this.rewelcomed.get(groupId)?.get(key);
+		return last !== void 0 && this.now() - last < REWELCOME_MS;
+	}
+	noteRewelcome(groupId, key) {
+		let sent = this.rewelcomed.get(groupId);
+		if (!sent) this.rewelcomed.set(groupId, sent = /* @__PURE__ */ new Map());
+		sent.set(key, this.now());
+	}
+	unwelcomed(group, session, key) {
+		if (!session.isAdmin || !group.unseen?.includes(key) || !rosterHas(session.roster, key)) return false;
+		const edge = this.host.edges(group.id).get(key);
+		return !(edge && this.host.linkReady(edge));
+	}
 	/** Records that a member's app takes rosters past eight; true when that is news (the caller saves). */
 	markLarge(group, key) {
 		if (group.large?.includes(key)) return false;
@@ -26676,13 +27458,19 @@ var Groups = class {
 		if (out.length) this.lastGossip.set(groupId, now);
 		return out;
 	}
+	/** When `via` was last asked for another member's messages (`askOf`), or 0: what it sends written before that is its answer. */
+	askedAt(groupId, via) {
+		let at = 0;
+		for (const asked of this.relayAsked.get(groupId)?.values() ?? []) if (asked.via === via && asked.at > at) at = asked.at;
+		return at;
+	}
 	/**
 	* Whether the answer of the member asked for someone's messages may still be coming: its edge up, asked under
-	* `MESH_SYNC_HOLD_MAX_MS` ago, and a message from it (or the asking) under `MESH_SYNC_HOLD_MS` ago.
+	* `MESH_SYNC_HOLD_MAX_MS` ago, and a message of its answer (or the asking) under `MESH_SYNC_HOLD_MS` ago.
 	*/
 	answering(groupId, { via, at }, now) {
 		const edge = this.host.edges(groupId).get(via);
-		if (!edge || !this.host.linkReady(edge) || now - at >= 1e4) return false;
+		if (!edge || !this.host.linkReady(edge) || now - at >= 18e4) return false;
 		return now - Math.max(at, this.lastHanded.get(groupId)?.get(via) ?? 0) < MESH_SYNC_HOLD_MS;
 	}
 	/**
@@ -26702,21 +27490,41 @@ var Groups = class {
 		held.set(peerKey, { ...asked });
 		return true;
 	}
-	/** The syncs that waited for another member's answer (`holdSync`), once it has come: for what it did not hand on. */
+	/**
+	* The syncs that waited for another member's answer (`holdSync`), once it has come: for what it did not hand on.
+	* One member at a time: the first is told and asked for the others too, which wait for its answer in turn. Told
+	* together, each answered with its own messages alone, and when the member asked first had been away too (it held
+	* little of what was missed) a conversation came as one member's lines, then the next's.
+	*/
 	heldSyncs(groupId, session, now) {
 		const held = this.syncHeld.get(groupId);
 		if (!held?.size) return;
-		const edges = this.host.edges(groupId);
-		for (const [key, asked] of held) {
-			if (this.answering(groupId, asked, now)) continue;
+		const edges = this.host.edges(groupId), asked = this.relayAsked.get(groupId);
+		const due = [];
+		for (const [key, of] of held) {
+			if (this.answering(groupId, of, now)) continue;
 			held.delete(key);
-			if (this.relayAsked.get(groupId)?.get(key)?.via === asked.via) this.relayAsked.get(groupId).delete(key);
+			if (asked?.get(key)?.via === of.via) asked.delete(key);
 			const edge = edges.get(key);
-			if (!edge || !this.host.linkReady(edge) || !rosterHas(session.roster, key)) continue;
-			try {
-				this.host.sendOnLink(edge, session.syncFrame(this.askOf(groupId, session, key)));
-			} catch {}
+			if (edge && this.host.linkReady(edge) && rosterHas(session.roster, key)) due.push(key);
+		}
+		const [next, ...rest] = due;
+		if (!next) return;
+		const ask = new Set(this.askOf(groupId, session, next));
+		for (const key of rest) {
+			ask.add(key);
+			asked?.set(key, {
+				via: next,
+				at: now
+			});
+			held.set(key, {
+				via: next,
+				at: now
+			});
 		}
+		try {
+			this.host.sendOnLink(edges.get(next), session.syncFrame([...ask]));
+		} catch {}
 	}
 	/**
 	* Reachable members whose messages below the highest seen never reached me, for `via` to hand on: their own answer
@@ -26772,15 +27580,16 @@ var Groups = class {
 		let tried = this.gapsAsked.get(groupId);
 		if (!tried) this.gapsAsked.set(groupId, tried = /* @__PURE__ */ new Map());
 		let entry = tried.get(via);
+		const now = this.now();
 		if (!entry || entry.mark !== mark) tried.set(via, entry = {
 			mark,
 			of: /* @__PURE__ */ new Set(),
-			noticed: entry?.noticed,
+			noticed: entry?.noticed ?? now,
 			last: entry?.last
 		});
 		if (entry.of.has(via)) return false;
 		entry.of.add(via);
-		entry.at = this.now();
+		entry.at = now;
 		return true;
 	}
 	/**
@@ -26870,11 +27679,14 @@ var Groups = class {
 				this.host.sendOnLink(edges.get(via), session.syncFrame(keys));
 			} catch {}
 		}
-		const others = connected.filter((key) => !fresh.has(key)), pool = others.length ? others : connected;
-		if (!fresh.size || !pool.length) return;
-		const via = pool[(gossipStart(session.myKey) + this.gossipTurn++) % pool.length];
+		if (!fresh.size || !connected.length) return;
+		const at = () => connected[(gossipStart(session.myKey) + this.gossipTurn++) % connected.length];
+		let via = at();
+		for (let i = 1; i < connected.length && fresh.has(via); i++) via = at();
 		const keys = this.gapsOf(groupId, session, via, fresh);
-		if (keys.length) try {
+		if (!keys.length) return;
+		this.lastGossip.set(groupId, now);
+		try {
 			this.host.sendOnLink(edges.get(via), session.syncFrame(keys));
 		} catch {}
 	}
@@ -26965,7 +27777,8 @@ var Groups = class {
 		if (!session) throw new Error("Group not found");
 		return session;
 	}
-	attach(state) {
+	/** `frames`: what the group's rows hold to hand on, oldest first (none yet for a group just made, joined or given back). */
+	attach(state, frames = []) {
 		const session = new GroupSession(state, {
 			clock: () => this.now(),
 			seqFloor: () => this.host.seqFloor?.() ?? 0,
@@ -27019,8 +27832,21 @@ var Groups = class {
 					...m.frame && { frame: m.frame }
 				};
 				const completed = !!m.completes && !!this.host.completeMessage;
+				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);
+				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,
+					at: this.now()
+				});
 				const came = m.sender === session.myKey ? timestamp : cameAt(timestamp, stored, arrivalNow(this.now()));
 				this.lastMessageAt.set(state.id, Math.max(this.lastMessageAt.get(state.id) ?? 0, came));
 				if (mentioned) this.lastMentionAt.set(state.id, Math.max(this.lastMentionAt.get(state.id) ?? 0, came));
@@ -27028,6 +27854,10 @@ var Groups = class {
 				noteCame(this.stored.get(state.id), came, m.sender !== session.myKey, mentioned);
 				this.typings.messageFrom(state.id, m.sender);
 			},
+			kept: async (id, frame) => {
+				await this.host.keepFrame?.(MESSAGE_LINK(state.id), id, frame).catch(() => {});
+				await this.frameKept(state.id, id, frame);
+			},
 			edit: (e) => this.host.groupEdit?.(state.id, e),
 			changed: () => {
 				if (session.status === "removed" && this.hubs.isHub(state.id) && !this.removedAt.has(state.id)) this.removedAt.set(state.id, this.now());
@@ -27040,7 +27870,7 @@ var Groups = class {
 				const edge = this.host.edges(state.id).get(to);
 				return edge && this.host.linkHandled ? this.host.linkHandled(edge) : Promise.resolve(false);
 			} }
-		});
+		}, frames);
 		this.sessions.set(state.id, session);
 		this.lastRoster.set(state.id, session.roster);
 		this.lastTold.set(state.id, {
@@ -27069,7 +27899,13 @@ var Groups = class {
 			for (const [key] of after) if (!rosterHas(before, key) && key !== session.myKey) await this.event(groupId, "joined", `${name(key)} joined`, when, top.e, key);
 			const gone = before.filter(([key]) => !rosterHas(after, key)).map(([key]) => key);
 			this.hubs.removed(groupId, gone, this.now());
-			for (const key of gone) await this.event(groupId, "gone", `${name(key)} is no longer a member`, when, top.e, key);
+			const left = (key) => {
+				const chain = session.state.chain;
+				for (let e = chain.length - 1; e > 0; e--) if (chain[e].k === "remove" && chain[e].s === key) return !!session.state.leftMarks?.[e];
+				return false;
+			};
+			for (const key of gone) if (left(key)) await this.event(groupId, "left", `${name(key)} left`, when, top.e, key);
+			else await this.event(groupId, "gone", `${name(key)} is no longer a member`, when, top.e, key);
 			if (top.k === "role") await this.event(groupId, "admin", `${name(top.s)} ${top.s === session.myKey ? "are" : "is"} now the admin`, when, top.e, top.s);
 			if (top.k === "rotate") await this.event(groupId, "rotated", "Keys rotated: a fresh epoch", when, top.e);
 		}
@@ -27124,16 +27960,21 @@ var Groups = class {
 	/** A line in the group's history; lines at the same time (two members gone in one change) get distinct ones, see `eventTime`. */
 	async event(groupId, event, text, timestamp, epoch, member) {
 		timestamp = eventTime(this.eventTimes, groupId, timestamp);
-		await this.host.storeMessage({
+		const id = `event:${epoch}:${event}:${timestamp}`;
+		this.lineOrder.placing(MESSAGE_LINK(groupId), {
+			id,
+			epoch,
+			line: true
+		}, this.now())(await this.host.storeMessage({
 			linkId: MESSAGE_LINK(groupId),
-			id: `event:${epoch}:${event}:${timestamp}`,
+			id,
 			text,
 			sender: "peer",
 			event,
 			member,
 			timestamp,
 			via: "datalink"
-		});
+		}) !== false);
 	}
 	eventTimes = /* @__PURE__ */ new Map();
 };
@@ -29087,8 +29928,6 @@ function resumeHere(log, runs, peer) {
 	const shared = runs.find((transport) => peer?.includes(transport));
 	return shared ? { resume: shared } : {};
 }
-/** A round trip that moved less than this is not news in the history. */
-var RTT_STEP_MS = 10;
 var sequence = 0;
 var lineId = (at) => `${at.toString(36)}-${(++sequence).toString(36)}`;
 /** A row that says the chat is live on its transport from then on. */
@@ -29212,8 +30051,7 @@ function historyFromRows(rows) {
 		});
 		else if (e.kind === "flapping") events.push({
 			...base,
-			kind: e.live ? "live" : "down",
-			reason: `Dropped and came back ${e.count ?? 0} times`
+			kind: e.live ? "live" : "down"
 		});
 		else if (e.kind === "connected" || e.kind === "back") events.push({
 			...base,
@@ -29493,7 +30331,7 @@ var TransportLog = class {
 			changed = true;
 		}
 		const stretch = [...this.history].reverse().find((e) => e.kind === "live" || e.kind === "switched" || e.kind === "down");
-		if (stretch && stretch.kind !== "down" && stretch.transport === on && (stretch.rttMs === void 0 || Math.abs(stretch.rttMs - ms) >= RTT_STEP_MS)) {
+		if (stretch && stretch.kind !== "down" && stretch.transport === on && (stretch.rttMs === void 0 || Math.abs(stretch.rttMs - ms) >= 10)) {
 			stretch.rttMs = ms;
 			changed = true;
 		}
@@ -30975,7 +31813,8 @@ var CashuWallet = class CashuWallet {
 				tx: walletTx(mint, kind, credited, Math.max(0, faceValue - credited), note),
 				...payment ? { payment: payment(credited, mint) } : {}
 			});
-			let swap = (await this.swapsAt(mint)).find((s) => s.kind === "receive" && s.token === token);
+			const written = (await this.swapsAt(mint)).filter((s) => s.kind === "receive");
+			let swap = written.find((s) => s.token === token);
 			if (swap?.finished) return {
 				amount: swap.tx?.amount ?? 0,
 				mint,
@@ -30983,6 +31822,8 @@ var CashuWallet = class CashuWallet {
 			};
 			if (!swap) {
 				const preview = await (await this.wallet(mint)).prepareSwapToReceive(token);
+				const redeeming = new Set(written.flatMap((s) => (swapOf(s).inputs ?? []).map((p) => p.secret)));
+				if (preview.inputs.some((p) => redeeming.has(p.secret))) throw engineError("ecashBeingReceived");
 				swap = {
 					id: swapId(),
 					mint,
@@ -31119,7 +31960,17 @@ var CashuWallet = class CashuWallet {
 			id: p.id
 		})));
 		if (states.length !== saved.inputs.length) throw new Error("The mint answered for another number of proofs");
-		if (states.some((s) => s.state === "PENDING")) return { state: "open" };
+		if (states.some((s) => s.state === "PENDING")) {
+			if (swap.kind === "receive" && refused) return {
+				state: "never",
+				gone: /* @__PURE__ */ new Set(),
+				final: true
+			};
+			return {
+				state: "open",
+				pending: true
+			};
+		}
 		const gone = new Set(saved.inputs.filter((_, i) => states[i]?.state === "SPENT").map((p) => p.secret));
 		if (gone.size > 0) {
 			const second = await signed();
@@ -31241,7 +32092,7 @@ var CashuWallet = class CashuWallet {
 	}
 	/**
 	* Swaps still written down: the app closed while the mint was being asked, or the mint did not answer. Each mint is
-	* asked where its own stand, under its lock. A swap it made is stored as its answer would have been; one it says it
+	* asked where its own stand, one swap at a time under its lock. A swap it made is stored as its answer would have been; one it says it
 	* never made is undone; one that is only overdue gives its inputs back and stays watched; one it cannot speak for
 	* is asked about again. `mints`: only these mints', once, now.
 	*/
@@ -31260,16 +32111,18 @@ var CashuWallet = class CashuWallet {
 		const later = (ms) => {
 			again = again ? Math.min(again, ms) : ms;
 		};
-		for (const mint of new Set(open.map((s) => s.mint))) await this.locked(mint, async () => {
-			for (let swap of await this.swapsAt(mint)) try {
+		for (const { id, mint } of open) await this.locked(mint, async () => {
+			let swap = await wrap((await store(STORES$1.swaps, "readonly")).get(id));
+			if (!swap) return;
+			try {
 				if (swap.finished) {
 					if (await this.tellSwap(swap, true)) await wrap((await store(STORES$1.swaps, "readwrite")).delete(swap.id));
 					else later(SWAP_POLL_MS);
-					continue;
+					return;
 				}
 				if (swap.askAt && Date.now() < swap.askAt && !mints) {
 					later(swap.askAt - Date.now());
-					continue;
+					return;
 				}
 				if (swap.attemptEndedAt === void 0) {
 					swap = {
@@ -31282,7 +32135,7 @@ var CashuWallet = class CashuWallet {
 				if (outcome.state === "open") {
 					if (swap.released && Date.now() >= swap.createdAt + SWAP_WATCH_MS) {
 						await this.dropSwap(swap, /* @__PURE__ */ new Set());
-						continue;
+						return;
 					}
 					if (outcome.slow) {
 						const stuck = (swap.stuck ?? 0) + 1;
@@ -31321,8 +32174,20 @@ var CashuWallet = class CashuWallet {
 							this.events.onChange();
 						} else later(SWAP_POLL_MS);
 					}
-					else later(swap.released ? SWAP_SLOW_POLL_MS : SWAP_POLL_MS);
-					continue;
+					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,
+								askAt: Date.now() + SWAP_SLOW_POLL_MS
+							}));
+							later(SWAP_SLOW_POLL_MS);
+						} else {
+							await this.dropSwap(swap, /* @__PURE__ */ new Set());
+							await this.tellSwap(swap, false);
+							this.events.onChange();
+						}
+					} else later(swap.released ? SWAP_SLOW_POLL_MS : SWAP_POLL_MS);
+					return;
 				}
 				if (outcome.state === "done") {
 					if (await this.finishSwap(swap, outcome.keep, outcome.send, true)) {
@@ -31333,7 +32198,7 @@ var CashuWallet = class CashuWallet {
 				} else if (swap.released) {
 					if (outcome.final || Date.now() >= swap.createdAt + SWAP_WATCH_MS) await this.dropSwap(swap, outcome.gone);
 					else later(SWAP_SLOW_POLL_MS);
-					continue;
+					return;
 				} else {
 					await this.dropSwap(swap, outcome.gone, !outcome.final);
 					await this.tellSwap(swap, false);
@@ -32787,12 +33652,27 @@ var PaymentDesk = class {
 			}
 			return;
 		}
-		if (done) await this.creditCashu(record, link);
-		else if (!this.payments.has(record.id)) link?.sendPaymentResult({
+		if (done) {
+			await this.creditCashu(record, link);
+			return;
+		}
+		if (this.payments.has(record.id)) return;
+		const reason = "The mint did not confirm the ecash";
+		link?.sendPaymentResult({
 			id: record.id,
 			ok: false,
-			error: "The mint did not confirm the ecash"
+			error: reason
 		});
+		try {
+			await this.host.storeMessage({
+				linkId: record.linkId,
+				id: `peer_${record.createdAt}_refused`,
+				text: `Could not receive ${record.amount.toLocaleString()} sats: ${reason}`,
+				sender: "peer",
+				timestamp: record.createdAt,
+				via: "datalink"
+			});
+		} catch {}
 	}
 	async onPaymentResult(linkId, result) {
 		const payment = this.find(linkId, result.id);
@@ -34383,24 +35263,6 @@ function messageAttention(type, message, { startedAt, newest, now }) {
 	};
 }
 //#endregion
-//#region ../browser/src/shared/hyperdhtRelay.ts
-/** Only `wss://`, or `ws://` to this machine (a relay for tests or development). */
-function hyperdhtRelayProblem(url) {
-	let parsed;
-	try {
-		parsed = new URL(url);
-	} catch {
-		return "Enter a relay address (wss://…)";
-	}
-	if (parsed.protocol === "wss:") return null;
-	if (parsed.protocol === "ws:" && [
-		"127.0.0.1",
-		"localhost",
-		"[::1]"
-	].includes(parsed.hostname)) return null;
-	return "Use a wss:// relay address";
-}
-//#endregion
 //#region ../browser/src/shared/pushRelay.ts
 /**
 * The push relay a browser hands wake-ups to when it may not post to a push service itself (WISP 401 § Wake-up
@@ -34551,10 +35413,10 @@ var NATIVE_SLOTS = 8;
 var IROH_WEB_SLOTS = 16;
 /** Of a transport's listeners, the ones a group's links never hold: 1:1 chats keep that room. */
 var CHAT_NATIVE_SLOTS = 4;
-/** How often a group link that found no free native slot tries again. */
-var GROUP_NATIVE_RETRY_MS = 15e3;
-/** The longest a group link whose native listener failed to start waits before trying again (its wait doubles up to it). */
-var GROUP_NATIVE_FAILED_MAX_MS = 3e5;
+/** How often a group link that found no free native slot tries again, and the first wait of a listener that failed to start. */
+var NATIVE_RETRY_MS = 15e3;
+/** The longest a chat or a group link whose native listener failed to start waits before trying again (its wait doubles up to it). */
+var NATIVE_FAILED_MAX_MS = 3e5;
 /** "Clear all data": how long taking things back from the network may hold up the clear, in all. */
 var CLEAR_WITHDRAW_MS = 6e3;
 /**
@@ -34583,11 +35445,19 @@ var DEFAULT_SETTINGS = {
 */
 var CARD_RESTORE_MOST = 50;
 var CARD_RESTORE_MS = 6048e5;
+/**
+* A round trip that moved is shown at once, and written to disk by itself (relaxed, no disk sync of its own) at most
+* this often: a 15 s sample on an internet path moves by 10 ms most of the time. A power cut loses at most this much
+* of the round trip's drift, never a row; any other change to the story writes the latest round trip with it.
+*/
+var RTT_SAVE_MS = 3e5;
 /** A reaction said on the live session and not confirmed is said again after this long. */
 var REACTION_RESEND_MS = 3e4;
 /** A file or a payment request of mine that waits for the chat to be live (a text that waits is its outbox's). */
 var waitsForLive = (m) => m.sender === "me" && m.delivery === "waiting" && (!!m.file || !!m.paymentId);
 /** This side's participation key in a chat: derived from its seed once, not at every state built. */
+/** A read of the contact's packet that found it as the last one did: online the same, the same packet, name and services. */
+var samePresence = (a, b) => a.online === b.online && a.lastPacketAt === b.lastPacketAt && a.seenAt === b.seenAt && a.nick === b.nick && JSON.stringify(a.services) === JSON.stringify(b.services);
 function participationKeyOf(live) {
 	const seed = live.stored.participationSeed;
 	if (!seed) return void 0;
@@ -34765,7 +35635,7 @@ var GhostlyNode = class GhostlyNode {
 	* Everything that publishes, dials, polls or settles asks this, not the stored setting.
 	*/
 	get networkOn() {
-		return !!this.settings.online && !this.limitedMode;
+		return !!this.settings.online && !this.limitedMode && !this.options.offline;
 	}
 	transport;
 	/** The same, for groups' requests: a relay budget keeps a chat's share from them (`CHAT_RESERVE`). */
@@ -34783,10 +35653,11 @@ var GhostlyNode = class GhostlyNode {
 	});
 	clockOff;
 	/**
-	* Edges of groups whose WebRTC did not connect in this run of the app (`edgeWithoutRtc`): they go on as an app with
-	* no WebRTC does, over a native transport. Not kept: the next start tries WebRTC first again.
+	* Edges of groups whose WebRTC did not connect (`edgeWithoutRtc`): they go on as an app with no WebRTC does, over a
+	* native transport, until the member is seen online again after a packet said it was gone (`away`, `edgeRtcPresence`).
+	* Not kept: the next start tries WebRTC first again.
 	*/
-	edgeRtcOff = /* @__PURE__ */ new Set();
+	edgeRtcOff = /* @__PURE__ */ new Map();
 	pollIntervals;
 	localFetch;
 	links = /* @__PURE__ */ new Map();
@@ -34809,6 +35680,8 @@ var GhostlyNode = class GhostlyNode {
 	});
 	/** `start` has put the kept transfers back (EngineState.transfersRestored). */
 	transfersRestored = false;
+	/** `start` has loaded the groups (EngineState.groupsLoaded). */
+	groupsLoaded = false;
 	feedbackStartedAt = Date.now();
 	feedbackIds = /* @__PURE__ */ new Set();
 	walletFeedbackReady = false;
@@ -34892,9 +35765,15 @@ var GhostlyNode = class GhostlyNode {
 	groupWakeReceived = /* @__PURE__ */ new Map();
 	requestCounts = /* @__PURE__ */ new Map();
 	transfers = /* @__PURE__ */ new Map();
+	/**
+	* Views that go in the next state sent, and then away (`GroupFilesHost.brief`): dropped once a state carried them,
+	* unless another view took their place meanwhile.
+	*/
+	briefViews = /* @__PURE__ */ new Map();
 	/** files/3 in every chat: offers, resumable transfers, checked by digest (WISP 501 rev 0.3). */
 	fileDesk = new FileDesk({
 		send: (linkId, frame) => this.links.get(linkId)?.link?.sendFilesFrame(frame) ?? false,
+		sendData: (linkId, id, offset, data) => this.links.get(linkId)?.link?.sendFileData(id, offset, data) ?? false,
 		writable: (linkId) => this.links.get(linkId)?.link?.filesWritable(),
 		receivedBytes: (linkId) => this.links.get(linkId)?.files.receivedBytes ?? 0,
 		wireIds: (linkId) => this.links.get(linkId)?.files.wireIds,
@@ -35670,6 +36549,10 @@ var GhostlyNode = class GhostlyNode {
 		forgetFrame: async (linkId, id) => {
 			await db.patchMessage(linkId, id, (stored) => stored.frame ? { frame: void 0 } : null, true);
 		},
+		keepFrame: async (linkId, id, frame) => {
+			await db.patchMessage(linkId, id, () => ({ frame }), true);
+		},
+		placeAgain: (linkId, ids) => this.placeAgain(linkId, ids),
 		membersChanged: (groupId) => this.groupMembersChanged(groupId),
 		historyGone: (groupId) => this.groupHistoryGone(groupId),
 		emit: () => this.emitState(),
@@ -35690,11 +36573,16 @@ var GhostlyNode = class GhostlyNode {
 		groupFiles: {
 			store: storedGroupFiles,
 			transfers: this.transfers,
+			brief: (id) => {
+				const view = this.transfers.get(id);
+				if (view) this.briefViews.set(id, view);
+			},
 			settings: () => ({
 				autoDownloads: this.settings.autoDownloads !== false,
 				serveFiles: this.settings.serveFiles !== false
 			}),
 			sendFiles: (linkId, frame) => this.links.get(linkId)?.link?.sendFilesFrame(frame) ?? false,
+			sendData: (linkId, id, offset, data) => this.links.get(linkId)?.link?.sendFileData(id, offset, data) ?? false,
 			writable: (linkId) => this.links.get(linkId)?.link?.filesWritable()
 		}
 	});
@@ -36087,7 +36975,7 @@ var GhostlyNode = class GhostlyNode {
 			const messages = stored.group ? [] : await db.getMessages(stored.id);
 			const storedFiles = stored.group ? [] : await fileStore.listForLink(stored.id);
 			const waiting = new Set(messages.flatMap((m) => m.sender === "me" && m.delivery === "waiting" && m.file ? [m.file.id] : []));
-			for (const file of storedFiles) if (file.transfer && !file.wire3 && !waiting.has(file.id)) this.transfers.set(file.id, file.transfer.state === "transferring" ? {
+			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."
@@ -36105,6 +36993,7 @@ var GhostlyNode = class GhostlyNode {
 		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);
@@ -36123,7 +37012,7 @@ var GhostlyNode = class GhostlyNode {
 			this.prepareSpare(STARTUP_QUIET_MS);
 		}
 		if (!this.limitedMode) this.openStartedWallets(fresh);
-		if (this.appsOn) this.appStore.start().catch(() => {});
+		if (this.appsOn && !this.appsWireOnly) this.appStore.start().catch(() => {});
 		if (!this.options.singleDevice && this.networkOn && knownDeviceGate()?.state === "active") this.startDeviceSet().catch(() => {});
 		if (!this.options.singleDevice && this.limitedMode && knownDeviceGate()?.state === "active") this.readTurnWhileLimited();
 		if (this.restoreCheck === "checking" && this.limitedMode) this.checkRestoredTurn(0);
@@ -36588,7 +37477,7 @@ var GhostlyNode = class GhostlyNode {
 	appShelf;
 	/** The installed apps and stores, refused while the apps feature is off. */
 	get appStore() {
-		if (!this.appsOn) throw this.appsOff();
+		if (!this.appsOn || this.appsWireOnly) throw this.appsOff();
 		return this.appShelf ??= new Apps({
 			fetch: boundedAppFetch({
 				fetcher: this.options.appFetch,
@@ -36599,12 +37488,16 @@ var GhostlyNode = class GhostlyNode {
 				return !!stored && !stored.group && !!stored.profile && !!stored.pairedPeerKey;
 			},
 			online: () => this.networkOn && !this.shuttingDown,
-			checked: () => this.events.onAppsChecked?.()
+			checked: () => this.events.onAppsChecked?.(),
+			...this.options.builtInApp && { readBuiltIn: this.options.builtInApp }
 		});
 	}
 	appList() {
 		return this.appStore.list();
 	}
+	appBuiltIns() {
+		return this.appStore.builtIns();
+	}
 	appStoreList() {
 		return this.appStore.listStores();
 	}
@@ -36650,6 +37543,9 @@ var GhostlyNode = class GhostlyNode {
 	appFile(params) {
 		return this.appStore.file(params);
 	}
+	appFileAt(params) {
+		return this.appStore.fileAt(params);
+	}
 	appStorageGet(params) {
 		return this.appStore.storageGet(params);
 	}
@@ -36665,6 +37561,9 @@ var GhostlyNode = class GhostlyNode {
 	appDataExport(params) {
 		return this.appStore.exportData(params);
 	}
+	appDataExportText(params) {
+		return this.appStore.exportDataText(params);
+	}
 	getState() {
 		const groups = this.groups.views();
 		return {
@@ -36692,6 +37591,7 @@ var GhostlyNode = class GhostlyNode {
 			})).sort((a, b) => a.createdAt - b.createdAt),
 			transfers: Object.fromEntries(this.transfers),
 			transfersRestored: this.transfersRestored,
+			...this.groupsLoaded && { groupsLoaded: true },
 			wallet: this.walletView,
 			payments: this.desk.views(),
 			identityProofs: this.identities.views(),
@@ -36849,9 +37749,17 @@ var GhostlyNode = class GhostlyNode {
 			madeAt: Date.now()
 		};
 	}
-	/** One invite warmed and waiting (`after` ms from now), warmed again every so often while it waits (the relays forget). */
+	/**
+	* One invite warmed and waiting (`after` ms from now), warmed again every so often while it waits (the relays forget).
+	* Once too old for `takeInvite` to hand out, it is replaced by a new one, warmed at once: warming it on would spend
+	* two puts every few minutes on keys nobody will use, and leave the next invite on cold keys.
+	*/
 	prepareSpare(after = 0) {
 		if (this.shuttingDown || !this.networkOn) return;
+		if (this.spare && after === 0 && Date.now() - this.spare.madeAt >= SPARE_INVITE_MAX_AGE_MS) {
+			for (const identity of [identityFromSeedB64(this.spare.mine.seedB64), this.spare.inviteKey]) this.warmedKeys.delete(identity.pubKeyZ32);
+			this.spare = null;
+		}
 		if (!this.spare) this.spare = this.makeSpare();
 		const spare = this.spare;
 		if (this.spareTimer) clearTimeout(this.spareTimer);
@@ -36867,10 +37775,11 @@ var GhostlyNode = class GhostlyNode {
 			this.warmedKeys.set(identity.pubKeyZ32, Date.now());
 			this.warmKey(identity);
 		}
+		const untilAged = spare.madeAt + SPARE_INVITE_MAX_AGE_MS - Date.now();
 		this.spareTimer = setTimeout(() => {
 			this.spareTimer = null;
 			if (this.spare === spare) this.prepareSpare();
-		}, SPARE_INVITE_WARM_EVERY_MS);
+		}, Math.min(SPARE_INVITE_WARM_EVERY_MS, untilAged));
 	}
 	async joinLink({ inviteCode }) {
 		const decoded = decodeInviteCode(inviteCode);
@@ -37535,7 +38444,7 @@ var GhostlyNode = class GhostlyNode {
 			this.transport.networkChanged?.();
 			this.directPath.reset();
 		}
-		if (params.network) for (const failed of this.groupNativeFailed.values()) {
+		if (params.network) for (const failed of this.nativeFailed.values()) {
 			failed.at = 0;
 			failed.wait = 0;
 		}
@@ -37749,14 +38658,23 @@ var GhostlyNode = class GhostlyNode {
 	/**
 	* The message of a chat a reply answers, by its id here or the id both sides know it by (`replyRef`): what the
 	* reply keeps of it, or why there is nothing to reply to. A group's reply needs the author's member key too.
+	* Read alone by its id, or a chat's `peer_`/`me_` row for a wire id, as `resolveReply` does: a group's message goes
+	* by its row's id, so a miss there is not here; a chat's other rows (a file's, a payment's) are looked for in the
+	* whole chat.
 	*/
 	async replyFor(linkId, messageId) {
 		if (typeof messageId !== "string" || !messageId) return "No message to reply to";
-		const messages = await db.getMessages(linkId);
-		const original = messages.find((m) => m.id === messageId) ?? messages.find((m) => replyRef(m) === messageId);
+		const group = linkId.startsWith("group:");
+		let original = await db.getMessage(linkId, messageId);
+		for (const rowId of group ? [] : [`peer_${messageId}`, `me_${messageId}`]) {
+			if (original) break;
+			const row = await db.getMessage(linkId, rowId);
+			if (row && replyRef(row) === messageId) original = row;
+		}
+		if (!original && !group) original = (await db.getMessages(linkId)).find((m) => replyRef(m) === messageId);
 		const ref = original && replyRef(original);
 		if (!original || !ref) return "That message is not in this chat, or cannot be replied to";
-		if (linkId.startsWith("group:") && !original.member) return "That message cannot be replied to";
+		if (group && !original.member) return "That message cannot be replied to";
 		return replyTo(original, ref);
 	}
 	/**
@@ -38094,6 +39012,7 @@ var GhostlyNode = class GhostlyNode {
 			const chat = this.links.get(linkId)?.stored;
 			outbox = new Outbox({
 				read: () => db.getMessages(linkId),
+				get: (id) => db.getMessage(linkId, id),
 				update: async (id, delivery, error, extra) => {
 					if (delivery === "delivered") await db.patchMessage(linkId, id, (message) => message.delivery === "delivered" ? null : {
 						...message.delivery && {
@@ -39175,19 +40094,40 @@ var GhostlyNode = class GhostlyNode {
 		const cue = transportCue(mark, log.entries, log.history);
 		if (cue) this.cueFeedback(cue, linkId);
 	}
-	saveTransportLog(live, log) {
+	/** `toDisk: false` shows the story and leaves the disk as it is; `relaxed`: written with no disk sync of its own. */
+	saveTransportLog(live, log, { toDisk = true, relaxed = false } = {}) {
 		const transportLog = log.entries.map((e) => ({ ...e })), transportHistory = log.history.map((e) => ({ ...e }));
 		live.stored = {
 			...live.stored,
 			transportLog,
 			transportHistory
 		};
-		db.patchLink(live.stored.id, {
-			transportLog,
-			transportHistory
-		}).catch(() => {});
+		if (toDisk) {
+			live.rttUnsaved = false;
+			db.patchLink(live.stored.id, {
+				transportLog,
+				transportHistory
+			}, relaxed).catch(() => {});
+		}
 		this.emitState();
 	}
+	/** A round trip measured on the chat's transport: in the view at once, on disk at most every `RTT_SAVE_MS`. */
+	noteRtt(live, ms) {
+		const moved = live.rttPosted === void 0 || Math.abs(live.rttPosted - ms) >= 10;
+		const log = this.transportLogOf(live);
+		if (!log) {
+			if (moved) this.emitState();
+			return;
+		}
+		const changed = log.rtt(ms);
+		if (changed) live.rttUnsaved = true;
+		const now = Date.now();
+		if (live.rttUnsaved && (live.rttSavedAt === void 0 || now - live.rttSavedAt >= RTT_SAVE_MS)) {
+			live.rttSavedAt = now;
+			this.saveTransportLog(live, log, { relaxed: true });
+		} else if (changed) this.saveTransportLog(live, log, { toDisk: false });
+		else if (moved) this.emitState();
+	}
 	/** Which ways of paying one chat allows. */
 	/** `networks`: for a way of paying, the networks this chat takes it on (the Accept side's cards); the others are kept. */
 	async setChatPaymentMethods({ linkId, methods, networks }) {
@@ -39219,7 +40159,9 @@ var GhostlyNode = class GhostlyNode {
 	async connect({ linkId }) {
 		const link = this.links.get(linkId)?.link;
 		if (!link) throw new Error("You are offline. Go online before reconnecting.");
-		await this.ensureNativeEndpoints(linkId);
+		const live = this.links.get(linkId), native = this.ensureNativeEndpoints(linkId);
+		const { preferredTransport: preferred, transportFallback: fallback } = live.stored;
+		if (this.reachedOnlyNatively(live) || fallback === false && preferred && preferred !== "webrtc/1") await native;
 		await link.connect();
 	}
 	disconnect({ linkId }) {
@@ -39729,11 +40671,22 @@ var GhostlyNode = class GhostlyNode {
 	}
 	/** Mini-apps are on in this build (`APPS_ENABLED`) or for this engine (`apps`). */
 	get appsOn() {
-		return this.options.apps ?? true;
+		return !!(this.options.apps ?? true);
 	}
-	/** Why an app call is refused: this client runs no mini-app (`apps: false`), or the build has them off. */
+	/** `apps/1` only (`apps: "wire"`): this host runs no mini-app and keeps no store, so nothing is installed here to check. */
+	get appsWireOnly() {
+		return this.options.apps === "wire";
+	}
+	/** Why an app call is refused: this client runs no mini-app (`apps: false`, or `"wire"` for the store's), or the build has them off. */
 	appsOff() {
-		return /* @__PURE__ */ new Error(this.options.apps === false ? "Apps do not run on this client" : "Apps are unavailable in this release");
+		return /* @__PURE__ */ new Error(this.options.apps === false || this.appsWireOnly ? "Apps do not run on this client" : "Apps are unavailable in this release");
+	}
+	/** Before an app's frames go to a contact: a version removed or revoked here says nothing more (WISP 1200 § Takedowns). */
+	async appChatRunnable(ref, digest) {
+		if (!this.appsWireOnly) await this.appStore.chatRunnable({
+			ref,
+			digest
+		});
 	}
 	/** A paired 1:1 chat and the chat app id of `ref` in it, from the two pinned participation keys (WISP 1200 § In a chat). */
 	appChat(linkId, ref) {
@@ -39759,10 +40712,7 @@ var GhostlyNode = class GhostlyNode {
 	async appOpen({ linkId, ref, version, digest }) {
 		const { live, app } = this.appChat(linkId, ref);
 		if (!isAppVersion(version)) throw new Error("Not an app version");
-		await this.appStore.chatRunnable({
-			ref,
-			digest
-		});
+		await this.appChatRunnable(ref, digest);
 		const open = live.appsOpen ??= /* @__PURE__ */ new Map();
 		if (live.link) live.link.openApp(app, version);
 		else open.set(app, version);
@@ -39778,10 +40728,7 @@ var GhostlyNode = class GhostlyNode {
 	async appSend({ linkId, ref, data, digest }) {
 		const { live, app } = this.appChat(linkId, ref);
 		if (!live.appsOpen?.has(app)) return { error: "not-open" };
-		await this.appStore.chatRunnable({
-			ref,
-			digest
-		});
+		await this.appChatRunnable(ref, digest);
 		return { error: live.link ? live.link.sendAppData(app, data) : "offline" };
 	}
 	/** Every page went away: no app runs here any more, so each open one is closed (`close` goes where it can). */
@@ -40908,6 +41855,7 @@ var GhostlyNode = class GhostlyNode {
 		const settings = rest;
 		delete settings.backupReminders;
 		const wasOnline = this.networkOn;
+		if (Array.isArray(settings.iceServers)) settings.iceServers = settings.iceServers.map(iceServerSetting);
 		for (const server of settings.iceServers ?? []) {
 			const problem = iceServerProblem(server);
 			if (problem) throw new Error(problem);
@@ -41876,7 +42824,7 @@ var GhostlyNode = class GhostlyNode {
 		this.groupWakeReceived.delete(linkId);
 		this.quietEdges.delete(linkId);
 		this.groupNativeWaiting.delete(linkId);
-		this.groupNativeFailed.delete(linkId);
+		this.nativeFailed.delete(linkId);
 		this.groupNativeRetryAt = 0;
 		if (live.stored.wakeToken && this.meshEdge(live.stored)) {
 			const group = live.stored.group, peer = live.stored.groupPeer;
@@ -41992,7 +42940,7 @@ var GhostlyNode = class GhostlyNode {
 		if (this.groupEntryTimer || this.shuttingDown || this.options.deferGroups) return;
 		this.groupEntryTimer = setInterval(() => {
 			this.groups.tick().catch(() => {});
-			this.retryGroupNative();
+			this.retryNative();
 		}, 1e3);
 	}
 	stopGroupEntries() {
@@ -42035,6 +42983,7 @@ var GhostlyNode = class GhostlyNode {
 			usdtPaymentsSupport: !entry,
 			barkPaymentsSupport: !entry,
 			largeFilesSupport: !entry,
+			binaryFilesSupport: !entry,
 			params: stored,
 			rtcAvailable: typeof RTCPeerConnection !== "undefined" && !this.edgeRtcOff.has(linkId),
 			resume: !entry && stored.edgeLive ? resumeOn : void 0,
@@ -42140,9 +43089,11 @@ var GhostlyNode = class GhostlyNode {
 						role,
 						packetAt: presence.lastPacketAt
 					});
+					const same = samePresence(live.presence, presence);
 					live.presence = presence;
 					if (!entry && presence.nick && !live.link?.isDataLinkOpen) this.groups.edgeNick(group, peer, presence.nick);
-					this.emitState();
+					if (!entry) this.edgeRtcPresence(linkId, presence);
+					if (!same) this.emitState();
 				},
 				onPairingState: (state) => {
 					live.pairing = state;
@@ -42199,14 +43150,44 @@ var GhostlyNode = class GhostlyNode {
 	* never went live, and the member stayed unreachable for as long as that network lasted. The edge starts again as on an
 	* app with no WebRTC (WISP 902 § Transports): it runs its native endpoints and says so in its packet (`_tr`, with no
 	* `webrtc/1`), the member's app starts its own for it as it does for a Linux Desktop, and the two meet over Iroh
-	* through its relay. For this run of the app only.
+	* through its relay. Until the member comes back (`edgeRtcPresence`), or for this run of the app.
 	*/
 	async edgeWithoutRtc(linkId) {
-		const live = this.links.get(linkId), link = live?.link;
-		if (!live || !link || !live.stored.group || live.stored.groupEntry || this.shuttingDown || this.options.webrtcGroupLinks) return;
+		const live = this.links.get(linkId);
+		if (!live?.link || !live.stored.group || live.stored.groupEntry || this.shuttingDown || this.options.webrtcGroupLinks) return;
 		if (this.edgeRtcOff.has(linkId) || this.keepsGroupNative(live.stored) || !Object.keys(this.nativeFactories).length) return;
-		this.edgeRtcOff.add(linkId);
+		this.edgeRtcOff.set(linkId, { away: false });
 		traceLink(live.myPubKeyZ32, "edge-rtc-off", {});
+		await this.restartEdge(linkId);
+	}
+	/**
+	* A member whose edge went native here (`edgeWithoutRtc`) is seen online again after a packet said it was gone: the
+	* attempt that failed may have been its app quitting in the middle of it (a one-shot CLI command, a quick restart),
+	* not a network that blocks direct connections. Held native for this whole run, the edge said so in its packet, the
+	* member's app followed on its next starts, and past the group links' native slots members stayed unreachable for as
+	* long as this app ran (2026-10-09). The edge tries WebRTC again, its `_tr` with `webrtc/1` again (WISP 902 §
+	* Transports); a network that really blocks it costs one more failed attempt per return.
+	*/
+	edgeRtcPresence(linkId, presence) {
+		const off = this.edgeRtcOff.get(linkId);
+		if (!off) return;
+		if (!presence.online) {
+			off.away = true;
+			return;
+		}
+		if (!off.away) return;
+		const live = this.links.get(linkId);
+		this.edgeRtcOff.delete(linkId);
+		if (live) traceLink(live.myPubKeyZ32, "edge-rtc-back", {});
+		this.groupNativeWaiting.delete(linkId);
+		this.nativeFailed.delete(linkId);
+		this.groupNativeRetryAt = 0;
+		this.restartEdge(linkId);
+	}
+	/** An edge starts again, on what `keepsGroupNative` says now. */
+	async restartEdge(linkId) {
+		const live = this.links.get(linkId), link = live?.link;
+		if (!live || !link) return;
 		live.link = null;
 		await link.stop(false).catch(() => {});
 		if (this.links.get(linkId) !== live || live.link || this.shuttingDown || !this.networkOn) return;
@@ -42240,6 +43221,7 @@ var GhostlyNode = class GhostlyNode {
 			callsSupport: this.options.callsSupport ?? typeof RTCPeerConnection !== "undefined",
 			callsMissing: this.options.callsUnavailable,
 			largeFilesSupport: true,
+			binaryFilesSupport: true,
 			typingSupport: true,
 			reactionsSupport: this.options.reactions !== false,
 			editSupport: !GhostlyNode.testNoEdit(),
@@ -42391,11 +43373,7 @@ var GhostlyNode = class GhostlyNode {
 					this.emitState();
 				},
 				onLiveAttempt: () => this.emitState(),
-				onRtt: (ms) => {
-					const log = this.transportLogOf(live);
-					if (log?.rtt(ms)) this.saveTransportLog(live, log);
-					else this.emitState();
-				},
+				onRtt: (ms) => this.noteRtt(live, ms),
 				onDiscoveryError: (error) => {
 					if ((error ?? void 0) !== live.discoveryError) {
 						live.discoveryError = error ?? void 0;
@@ -42428,16 +43406,17 @@ var GhostlyNode = class GhostlyNode {
 					const was = live.status, synced = live.lastSyncAt;
 					live.status = status;
 					if (status === "online") live.lastSyncAt = Date.now();
-					if (status !== was || !synced || stored.group || linkId === this.activeLinkId) this.emitState();
+					if (status !== was || !synced && status === "online" || stored.group || linkId === this.activeLinkId) this.emitState();
 				},
 				onPoll: ({ polling, nextInMs }) => {
-					const was = live.poll.polling;
+					const was = live.poll.polling, first = !live.lastSyncAt && !live.firstReadDone;
 					live.poll = {
 						polling,
 						nextAt: Date.now() + nextInMs,
 						interval: nextInMs || live.poll.interval
 					};
-					if (linkId === this.activeLinkId || !live.lastSyncAt && polling !== was) this.emitState();
+					if (was && !polling) live.firstReadDone = true;
+					if (linkId === this.activeLinkId || first && polling !== was) this.emitState();
 				},
 				onMessageReceipt: async (id) => {
 					const oneToOne = !!stored.profile && !stored.group;
@@ -42516,6 +43495,7 @@ var GhostlyNode = class GhostlyNode {
 					this.emitState();
 				},
 				onPresence: (presence) => {
+					let same = samePresence(live.presence, presence);
 					live.presence = presence;
 					if (!stored.profile && presence.nick && presence.nick !== live.stored.peerNick) {
 						live.stored = {
@@ -42523,8 +43503,9 @@ var GhostlyNode = class GhostlyNode {
 							peerNick: presence.nick
 						};
 						db.patchLink(linkId, { peerNick: presence.nick });
+						same = false;
 					}
-					this.emitState();
+					if (!same) this.emitState();
 				},
 				onMessage: (message) => {
 					if (live.stored.inviteCode) {
@@ -42719,7 +43700,7 @@ var GhostlyNode = class GhostlyNode {
 	get nativeFactories() {
 		const relay = this.relaysHyperdht ? this.hyperdhtRelay : "";
 		return {
-			...relay ? { "hyperdht/1": async (seedB64) => (await import("./hyperdhtRelay-hKC9DpIH.js")).createRelayedHyperEndpoint(seedB64, relay) } : {},
+			...relay ? { "hyperdht/1": async (seedB64) => (await import("./hyperdhtRelay-CEmBpT0Q.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 }) } : {}
@@ -42820,17 +43801,18 @@ var GhostlyNode = class GhostlyNode {
 		return Promise.all(starts).then((full) => {
 			const live = this.links.get(linkId), link = live?.link;
 			if (this.shuttingDown || !live || !link || link !== expected) return;
-			if (live.stored.group && this.keepsGroupNative(live.stored)) {
+			const group = !!live.stored.group;
+			if (group && this.keepsGroupNative(live.stored)) {
 				if (full.includes("no-slot") && !link.availableTransports.some((t) => t !== "webrtc/1")) this.groupNativeWaiting.add(linkId);
 				else this.groupNativeWaiting.delete(linkId);
-				if (full.includes("failed")) {
-					const wait = Math.min(Math.max(GROUP_NATIVE_RETRY_MS, (this.groupNativeFailed.get(linkId)?.wait ?? 0) * 2), GROUP_NATIVE_FAILED_MAX_MS);
-					this.groupNativeFailed.set(linkId, {
-						at: Date.now() + wait,
-						wait
-					});
-				} else this.groupNativeFailed.delete(linkId);
-			} else this.groupNativeFailed.delete(linkId);
+			}
+			if ((group ? this.keepsGroupNative(live.stored) : this.keepsNativeEndpoints(linkId, live.stored)) && full.includes("failed")) {
+				const wait = Math.min(Math.max(NATIVE_RETRY_MS, (this.nativeFailed.get(linkId)?.wait ?? 0) * 2), NATIVE_FAILED_MAX_MS);
+				this.nativeFailed.set(linkId, {
+					at: Date.now() + wait,
+					wait
+				});
+			} else this.nativeFailed.delete(linkId);
 			this.emitState();
 		});
 	}
@@ -42988,25 +43970,25 @@ var GhostlyNode = class GhostlyNode {
 	/** Group links waiting for a free native slot (`ensureNativeEndpoints`), by link id. */
 	groupNativeWaiting = /* @__PURE__ */ new Set();
 	groupNativeRetryAt = 0;
-	/** Group links whose native listener failed to start, by link id: when each tries again, and how long it waited last. */
-	groupNativeFailed = /* @__PURE__ */ new Map();
+	/** Chats and group links whose native listener failed to start, by link id: when each tries again, and how long it waited last. */
+	nativeFailed = /* @__PURE__ */ new Map();
 	/**
 	* Now and then, the group links that found no free native slot try again: a chat or another group may have let one go.
-	* Those whose listener failed to start try again once their wait is over.
+	* Chats and group links whose listener failed to start try again once their wait is over.
 	*/
-	retryGroupNative() {
+	retryNative() {
 		const now = Date.now();
-		for (const [linkId, failed] of this.groupNativeFailed) {
+		for (const [linkId, failed] of this.nativeFailed) {
 			if (now < failed.at) continue;
 			if (!this.links.get(linkId)?.link) {
-				this.groupNativeFailed.delete(linkId);
+				this.nativeFailed.delete(linkId);
 				continue;
 			}
 			failed.at = now + failed.wait;
 			this.ensureNativeEndpoints(linkId);
 		}
 		if (!this.groupNativeWaiting.size || Date.now() < this.groupNativeRetryAt) return;
-		this.groupNativeRetryAt = Date.now() + GROUP_NATIVE_RETRY_MS;
+		this.groupNativeRetryAt = Date.now() + NATIVE_RETRY_MS;
 		for (const linkId of [...this.groupNativeWaiting]) {
 			if (!this.links.get(linkId)?.link) {
 				this.groupNativeWaiting.delete(linkId);
@@ -43111,6 +44093,24 @@ var GhostlyNode = class GhostlyNode {
 		} else this.placedAt.set(message.linkId, Math.max(last, Math.min(message.timestamp, now)));
 		return message;
 	}
+	/**
+	* These rows, in this order, placed again below everything in their history, as if they came now: a group member's
+	* messages that came above an older one of theirs (WISP 400, requirement 10), and the lines that came after them. The
+	* places are taken before anything is awaited, so a row that comes meanwhile goes below them. Each still shows the
+	* time it showed. All of them in one write: one disk sync, not one a row.
+	*/
+	async placeAgain(linkId, ids) {
+		const places = new Map(ids.map((id) => {
+			const timestamp = arrivalKey(Date.now(), this.placedAt.get(linkId));
+			this.placedAt.set(linkId, timestamp);
+			return [id, timestamp];
+		}));
+		const moved = await db.patchMessages(linkId, [...places.keys()], (m) => ({
+			timestamp: places.get(m.id),
+			sentAt: shownTime(m)
+		}));
+		if (moved.length) await this.messagesChanged(linkId, moved.map((m) => m.id));
+	}
 	async storeMessage(message) {
 		await this.storeNewMessage(message);
 	}
@@ -43230,7 +44230,7 @@ var GhostlyNode = class GhostlyNode {
 			transportWait: live.link?.transportWait,
 			liveAttempt: live.link?.liveAttempt,
 			liveDialer: live.stored.profile && !live.stored.group ? live.link?.dialer : void 0,
-			transportRttMs: live.link?.rttMs,
+			transportRttMs: live.rttPosted = live.link?.rttMs,
 			transportRelayed: live.link?.relayedPath,
 			transportLive: live.transportLog?.liveNow(),
 			transportLog: stored.id === this.activeLinkId && stored.profile && !stored.group ? stored.transportLog ?? [] : void 0,
@@ -43252,7 +44252,10 @@ var GhostlyNode = class GhostlyNode {
 			lastMessageAt: live.lastMessageAt,
 			peerAck: live.peerAck,
 			lastSyncAt: live.lastSyncAt,
-			poll: live.poll
+			poll: live.firstReadDone && !live.lastSyncAt && stored.id !== this.activeLinkId ? {
+				...live.poll,
+				polling: false
+			} : live.poll
 		};
 	}
 	/** What this chat can do right now: on the open session, or held for an away contact (text, files and requests only). */
@@ -43285,6 +44288,7 @@ var GhostlyNode = class GhostlyNode {
 			this.stateTimer = null;
 			if (this.gatedOut) return;
 			this.events.onState(this.getState());
+			this.dropBriefViews();
 			if (this.deviceLinks) this.syncDeviceTokens();
 		}, delayMs);
 	}
@@ -43296,11 +44300,16 @@ var GhostlyNode = class GhostlyNode {
 		}
 		if (this.gatedOut) return;
 		this.events.onState(this.getState());
+		this.dropBriefViews();
+	}
+	/** A state went with the brief views: they go, so the next states do not carry them (`briefViews`). */
+	dropBriefViews() {
+		for (const [id, view] of this.briefViews) if (this.transfers.get(id) === view) this.transfers.delete(id);
+		this.briefViews.clear();
 	}
 };
 //#endregion
 //#region ../browser/src/engine/server.ts
-var server_exports = /* @__PURE__ */ __exportAll({ EngineServer: () => EngineServer });
 var EngineServer = class {
 	/** The whole engine: never made on a device that is not the active one (`devices/peer.ts` decides, WISP 06 § The gate). */
 	gated = false;
@@ -43372,6 +44381,10 @@ var EngineServer = class {
 	get historyMark() {
 		return this.changes;
 	}
+	/** Whether a chat's or group's history changed after `mark` (`historyMark`); with none, since this engine was made. */
+	historyChanged(id, mark = 0) {
+		return (this.changedAt.get(id) ?? 0) > mark;
+	}
 	/**
 	* `read`: the chats and groups whose whole history the client read itself, after `mark` (`historyMark`). One that has
 	* not changed since is not read and sent again: the client hears only what changes in it from now on.
@@ -43534,6 +44547,6 @@ function signalKind(signal) {
 	}
 }
 //#endregion
-export { EngineServer, hyperdhtRelayProblem as n, server_exports as t };
+export { EngineServer };
 
-//# sourceMappingURL=server-DHMXMwNn.js.map
+//# sourceMappingURL=server-CBCEYKMN.js.map