@ghostlytools/cli 1.2.4 → 1.3.1

package/dist/assets/{src-CbLkHfz8.js → src-DDzSERyc.js}

@@ -515,27 +515,31 @@ function signRelayPayload(identity, dnsPacket, seq) {
 	new DataView(timestamp.buffer).setBigUint64(0, seq);
 	return concatBytes$1(signature, timestamp, dnsPacket);
 }
-/** Checks a relay payload's size and signature. Returns its sequence number and DNS packet, not decoded. */
-function openRelayPayload(pubKeyZ32, payload) {
+/** A relay payload's parts, its size checked: the signature, the sequence number and the DNS packet (not decoded). */
+function splitRelayPayload(payload) {
 	if (payload.length < 84) throw new Error("Relay payload too short");
 	if (payload.length > 1072) throw new PacketTooLargeError(payload.length);
+	return {
+		signature: payload.subarray(0, SIGNATURE_LENGTH),
+		seq: new DataView(payload.buffer, payload.byteOffset + SIGNATURE_LENGTH, TIMESTAMP_LENGTH).getBigUint64(0),
+		dnsPacket: payload.subarray(72)
+	};
+}
+/** Checks a relay payload's size and signature. Returns its sequence number and DNS packet, not decoded. */
+function openRelayPayload(pubKeyZ32, payload) {
+	const { signature, seq, dnsPacket } = splitRelayPayload(payload);
 	const publicKey = publicKeyFromZ32(pubKeyZ32);
-	const signature = payload.subarray(0, SIGNATURE_LENGTH);
-	const seq = new DataView(payload.buffer, payload.byteOffset + SIGNATURE_LENGTH, TIMESTAMP_LENGTH).getBigUint64(0);
-	const dnsPacket = payload.subarray(72);
 	if (!verify(signature, signable(seq, dnsPacket), publicKey)) throw new Error("Invalid signature");
 	return {
 		seq,
 		dnsPacket
 	};
 }
-/** Verifies and decodes a relay payload. Throws if the signature does not match. */
-function parseRelayPayload(pubKeyZ32, payload) {
-	const { seq: timestampMicros, dnsPacket } = openRelayPayload(pubKeyZ32, payload);
+function decodeRelayPayload(pubKeyZ32, seq, dnsPacket) {
 	const suffix = `.${pubKeyZ32}`;
 	return {
 		pubKeyZ32,
-		timestampMicros,
+		timestampMicros: seq,
 		records: decodeTxtPacket(dnsPacket).map((r) => ({
 			label: r.name.endsWith(suffix) ? r.name.slice(0, -suffix.length) : r.name,
 			value: r.value,
@@ -543,6 +547,20 @@ function parseRelayPayload(pubKeyZ32, payload) {
 		}))
 	};
 }
+/** Verifies and decodes a relay payload. Throws if the signature does not match. */
+function parseRelayPayload(pubKeyZ32, payload) {
+	const { seq, dnsPacket } = openRelayPayload(pubKeyZ32, payload);
+	return decodeRelayPayload(pubKeyZ32, seq, dnsPacket);
+}
+/**
+* Decodes a payload whose signature this process made or already checked (one it is putting), without checking it
+* again: an Ed25519 verify costs about 1 ms, and a CLI daemon at its relay budget checked its own packets ~500 times a
+* minute. Never for bytes read from elsewhere: `parseRelayPayload` is.
+*/
+function readOwnRelayPayload(pubKeyZ32, payload) {
+	const { seq, dnsPacket } = splitRelayPayload(payload);
+	return decodeRelayPayload(pubKeyZ32, seq, dnsPacket);
+}
 /** How far ahead of this clock a packet's time may be and still count as now: clocks drift, not by this much. */
 var PKARR_FUTURE_SKEW_MS = 6e5;
 /**
@@ -700,9 +718,13 @@ var RelayBreaker = class {
 		this.circuits.delete(relay);
 		if (recovered) this.options.onRecover?.(relay);
 	}
-	/** The relay failed a request; a probe that fails trips it again at once. */
+	/**
+	* The relay failed a request; a probe that fails trips it again at once. While it is left alone and no probe is out,
+	* a failure is a request sent before it tripped (a start burst): already counted in, it trips nothing again.
+	*/
 	failure(relay, kind, reason) {
 		const circuit = this.circuit(relay);
+		if (!circuit.probing && circuit.openUntil > this.now()) return;
 		circuit.failures++;
 		circuit.kind = kind;
 		circuit.reason = reason;
@@ -832,6 +854,8 @@ function currentRelays(relays) {
 * only thing that peer is waiting for) would go out only once the polling slowed down, half a minute later.
 */
 var WRITE_FIRST_MS = 5e3;
+/** The most of a relay's minute the chats' reserve takes, however many chats need it: the rest stays for everything else. */
+var CHAT_RESERVE_MOST_SHARE = 5 / 6;
 /**
 * A 1:1 chat's signaling (a new offer or answer, and its reads for the answer to its offer, `signal`) may go over a
 * relay's minute by this fraction of it: 6 on a relay of 30, 12 on one of 60, 1 on relay.pkarr.org's 5 (it allows 10),
@@ -1167,14 +1191,22 @@ var RelayTransport = class {
 	}
 	/**
 	* Signs the records, dated by `nextTimestamp`, and hands the payload to `put` (the relays; the CLI adds the DHT).
+	* When every relay's budget (or rate limit) holds this asker back, it throws that wait before signing anything
+	* (`publishWait`): a daemon at its budget signed about 500 packets a minute that never went out. `elsewhere`: `put`
+	* also takes the packet where no budget holds it back (the CLI's DHT), so it is signed whatever the relays say.
 	* `put` calls `conflict` for a relay that answered 409: it holds a packet under this key dated at or after this one,
 	* which this client has not read (an inviter's warm packet under the key it gave its contact, from a clock ahead of
 	* this one). That packet is read from that relay, and the records go again dated just past it, once. Without this
 	* the packet was refused until this device's clock passed the other one's, however long that took, and on a relay
 	* that did take it, readers still preferred the later-dated empty packet of another relay.
 	*/
-	async publishDated(identity, records, put, options = {}, again = false) {
-		const key = identity.pubKeyZ32, timestamp = this.nextTimestamp(key);
+	async publishDated(identity, records, put, options = {}, again = false, elsewhere = false) {
+		const key = identity.pubKeyZ32;
+		if (!again && !elsewhere) {
+			const held = this.publishWait(key, asker(options, true));
+			if (held) throw new DiscoveryBudgetError(held.wait, `Publish held back on every relay: ${held.reasons.join("; ")}`);
+		}
+		const timestamp = this.nextTimestamp(key);
 		let redated;
 		const conflict = (relay) => {
 			if (again || redated) return;
@@ -1186,7 +1218,7 @@ var RelayTransport = class {
 					relay
 				});
 				if (this.lastTimestamp.get(key) !== timestamp) return true;
-				await this.publishDated(identity, records, put, options, true);
+				await this.publishDated(identity, records, put, options, true, elsewhere);
 				return true;
 			})();
 			redated.catch(() => {});
@@ -1198,6 +1230,46 @@ var RelayTransport = class {
 			if (!pending || !await pending) throw error;
 		}
 	}
+	/**
+	* How long until some relay takes a publish of this asker, and why each holds it back; null when one would now. Walks the relays as `put` does,
+	* without asking any: a relay the budget holds back gets its refused `take` (the asker's write then waits first in
+	* line, as when `put` is refused), one rate limiting or throttling this address is a wait, one left alone for failing
+	* is none. Null too when a relay fails another way (its network cooling down): the publish then goes, and fails, as
+	* before, and when no relay is held back at all.
+	*/
+	publishWait(pubKeyZ32, who) {
+		const probe = this.breaker.allDownProbe(this.relays);
+		let wait = Infinity;
+		const held = [], reasons = [];
+		for (const relay of this.relays) {
+			if (relay !== probe && this.networkCoolingDown(relay, "PUT")) return null;
+			const limited = this.rateLimitedFor(relay);
+			if (limited > 0) {
+				wait = Math.min(wait, limited);
+				reasons.push(`${relay}: Discovery relay is cooling down after a 429; retry shortly`);
+				continue;
+			}
+			const blocked = relay === probe ? 0 : this.breaker.blockedFor(relay);
+			if (blocked > 0) {
+				if (this.breaker.blockedKind(relay) === "throttled") {
+					wait = Math.min(wait, blocked);
+					reasons.push(`${relay}: Discovery relay is throttling this address; retry shortly`);
+				} else reasons.push(`${relay} is left alone after failing`);
+				continue;
+			}
+			if (this.heldFor(relay, who, Date.now(), pubKeyZ32) <= 0) return null;
+			held.push(relay);
+			const left = this.heldFor(relay, who);
+			wait = Math.min(wait, left);
+			reasons.push(`${relay}: discovery budget reached; retry in ${Math.ceil(left / 1e3)} s`);
+		}
+		if (wait === Infinity) return null;
+		for (const relay of held) this.take(relay, who, pubKeyZ32);
+		return {
+			wait,
+			reasons
+		};
+	}
 	/** One relay's packet for a key, read now: its time, kept for `nextTimestamp`. Null when it has none or does not answer. */
 	async heldAt(relay, pubKeyZ32, who) {
 		if (!this.take(relay, who, pubKeyZ32)) return null;
@@ -1217,10 +1289,22 @@ var RelayTransport = class {
 	sawTimestamp(pubKeyZ32, timestamp) {
 		if (timestamp > (this.seenTimestamp.get(pubKeyZ32) ?? 0n)) this.seenTimestamp.set(pubKeyZ32, timestamp);
 	}
-	/** Puts a payload signed elsewhere (a did:dht document), byte for byte, on every relay. `conflict`: as `publishDated` gives it. */
+	/**
+	* Puts a payload `publishDated` just signed, dated `timestamp`, on every relay. Its signature is not checked: it was
+	* made here (`publishPayload` checks one signed elsewhere, to read its sequence number). `conflict`: as `publishDated`
+	* gives it.
+	*/
+	async putSigned(pubKeyZ32, payload, timestamp, options = {}, conflict) {
+		if (this.relays.length === 0) throw new Error("No Pkarr relays configured");
+		await this.putEverywhere(pubKeyZ32, payload, timestamp, options, conflict);
+	}
+	/**
+	* Puts a payload signed elsewhere (a did:dht document), byte for byte, on every relay; one signed here says its date
+	* (`signedAt`) and is not checked again. `conflict`: as `publishDated` gives it.
+	*/
 	async publishPayload(pubKeyZ32, payload, options = {}, conflict) {
 		if (this.relays.length === 0) throw new Error("No Pkarr relays configured");
-		const { seq } = openRelayPayload(pubKeyZ32, payload);
+		const seq = options.signedAt ?? openRelayPayload(pubKeyZ32, payload).seq;
 		await this.putEverywhere(pubKeyZ32, payload, seq, options, conflict);
 	}
 	/**
@@ -1261,7 +1345,7 @@ var RelayTransport = class {
 				accepted = true;
 				noWriteWaits();
 				try {
-					this.written.set(pubKeyZ32, parseRelayPayload(pubKeyZ32, payload));
+					this.written.set(pubKeyZ32, readOwnRelayPayload(pubKeyZ32, payload));
 				} catch {}
 				resolve();
 			}, () => {});
@@ -1723,9 +1807,9 @@ var RelayTransport = class {
 			if (rationed.length >= most) wait = Math.max(wait, rationed[rationed.length - most] + GROUP_RATION_WINDOW_MS - now);
 			if (this.readsAhead(key, now) > 0) wait = Math.max(wait, TURN_WAIT_MS);
 		}
-		if (who.group) {
+		if (who.group || who.background) {
 			const reserved = this.chatReservedFor(relay, now);
-			if (reserved > 0) wait = Math.max(wait, Math.min(reserved, over(recent, limit - this.reserveOf(relay))));
+			if (reserved > 0) wait = Math.max(wait, Math.min(reserved, over(recent, limit - this.chatReserveOf(relay, now))));
 		}
 		const writer = firstWriter(who);
 		const waiting = (lane) => {
@@ -1835,6 +1919,12 @@ var RelayTransport = class {
 		if (share === void 0) return this.perMinute;
 		return this.perMinuteGiven ? Math.min(this.perMinute, share) : share;
 	}
+	/** What the chats that need the relays keep on this relay (`CHAT_RESERVE_PER_CHAT`), never less than `reserveOf`. */
+	chatReserveOf(relay, now) {
+		let needing = 0;
+		for (const need of this.chatNeeds.values()) if (now - Math.max(need.urgentAt, need.refused.get(relay) ?? -Infinity) < 6e4) needing++;
+		return Math.max(this.reserveOf(relay), Math.min(needing * 3, Math.floor(this.limitOf(relay) * CHAT_RESERVE_MOST_SHARE)));
+	}
 	/** What groups leave a chat on this relay: `CHAT_RESERVE`, or a third of a smaller budget. */
 	reserveOf(relay) {
 		return Math.min(10, Math.floor(this.limitOf(relay) / 3));
@@ -3060,6 +3150,12 @@ var OwnInviteError = class extends Error {
 		this.name = "OwnInviteError";
 	}
 };
+/** The refusal an error (or an error's message, as an RPC hands it over) carries, or null when it is another error. */
+function ownInviteRefusal(error) {
+	if (error instanceof OwnInviteError) return { linkId: error.linkId };
+	const match = (error instanceof Error ? error.message : typeof error === "string" ? error : "").match(/^own-invite(?: (\S+))?: /);
+	return match ? { linkId: match[1] ?? null } : null;
+}
 /** The `ghostly1z…` code of a device invite. */
 function encodeDeviceInvite(invite) {
 	const fields = [
@@ -5092,6 +5188,7 @@ function wrapDataChannel(dc) {
 		close() {
 			dc.close();
 		},
+		binary: true,
 		onMessage: null,
 		onClose: null
 	};
@@ -5103,11 +5200,31 @@ function wrapDataChannel(dc) {
 	dc.addEventListener("close", () => channel.onClose?.());
 	return channel;
 }
+/**
+* Resolves once the channel has room for a body's next chunk; undefined when it has now. A channel with a send budget
+* (native and iroh ones throw past 120 KiB) gives a body a quarter of it, as files/3 keeps to, so a ping or a message
+* still fits beside it; others keep under the high water mark.
+*/
+function bodyRoom(channel, isCancelled) {
+	if (!channel.sendBudget) return channel.bufferedAmount > LIMITS.sendHighWaterMark ? channel.drained() : void 0;
+	const line = channel.sendBudget / 4;
+	if (channel.bufferedAmount < line) return;
+	return (async () => {
+		while (!isCancelled() && channel.bufferedAmount >= line) {
+			await channel.drained().catch(() => {});
+			if (!isCancelled() && channel.bufferedAmount >= line) await new Promise((resolve) => setTimeout(resolve, 20));
+		}
+	})();
+}
 /** Writes a body as chunks, honouring backpressure. Always ends with an END chunk. */
 async function sendBody(channel, kind, id, body, isCancelled = () => false) {
 	for await (const part of body) for (let offset = 0; offset < part.length; offset += MAX_CHUNK_PAYLOAD_BYTES) {
 		if (isCancelled()) return;
-		if (channel.bufferedAmount > LIMITS.sendHighWaterMark) await channel.drained();
+		const room = bodyRoom(channel, isCancelled);
+		if (room) {
+			await room;
+			if (isCancelled()) return;
+		}
 		const payload = part.subarray(offset, offset + MAX_CHUNK_PAYLOAD_BYTES);
 		channel.send(encodeChunk({
 			kind,
@@ -5701,6 +5818,19 @@ var STALLED_LOOK_MS = 15e3;
 * #1441, on a loaded host), and past it the race's DHT dial has brought the chat back anyway.
 */
 var DEPARTED_READ_MS = EXPECT_PEER_MS;
+/** A chat whose contact was never seen (an invite just sent) keeps looking at the active pace this long. */
+var AWAITING_PEER_MS = 6e5;
+/**
+* An invite this side made that nobody used, once no longer awaited (`AWAITING_PEER_MS`), is read less often the older
+* it is: a fifth of its age between reads, up to this. Read at the background pace instead, 15 unused invites (their
+* keys and their mailboxes) asked the relays for 60 reads a minute for as long as the app ran: the relays' minute went
+* to invites nobody may ever open, and a join on one was noticed 90 s later (bug hunt 1013-1642, 2026-10-13).
+*/
+var UNUSED_INVITE_WAIT_MAX_MS = 18e4;
+/** The wait between reads of an unused invite of age `age` (`UNUSED_INVITE_WAIT_MAX_MS`), never shorter than the pace's `interval`. */
+function unusedInviteWait(age, interval) {
+	return Math.max(interval, Math.min(UNUSED_INVITE_WAIT_MAX_MS, Math.round(age / 5)));
+}
 var PUBLISH_RETRY_MS = 4e3;
 /**
 * A packet the relays' request budget held back goes again when the budget frees a request, and at least this often
@@ -5756,6 +5886,8 @@ var LinkSession = class {
 	startedAt = Date.now();
 	/** From when a peer never seen is awaited (`AWAITING_PEER_MS`): never later than this start, whatever the clock said when the chat was made. */
 	awaitingSince;
+	/** This side's invite, nobody used yet (`LinkSessionOptions.invite`). */
+	invite;
 	intervals;
 	fastPollUntil = 0;
 	/** An offer to a saved contact is out: from then on its fast window looks less often (`OFFER_FAST_MS`); 0 for none. */
@@ -5811,6 +5943,7 @@ var LinkSession = class {
 		this.events = options.events ?? {};
 		this.firstPublish = options.firstPublish ?? "at-start";
 		this.awaitingSince = Math.min(options.awaitingSince ?? this.startedAt, this.startedAt);
+		this.invite = options.invite ?? (() => false);
 	}
 	get peerPresence() {
 		return this.presence;
@@ -5984,8 +6117,8 @@ var LinkSession = class {
 	async setRtcSignal(signal, reportFailure = false) {
 		if (this.rtcSignal === signal) return;
 		this.rtcSignal = signal;
-		if (reportFailure) await this.publish();
-		else await this.publish().catch(() => {});
+		if (reportFailure) await this.publish(signal === null);
+		else await this.publish(signal === null).catch(() => {});
 		if (signal) this.pollNow();
 	}
 	/**
@@ -6058,6 +6191,7 @@ var LinkSession = class {
 		const stepping = this.fastStepsAfter ? Date.now() - this.fastStepsAfter : -1;
 		if (pace === "fast" && stepping >= 0) return Math.min(4 * interval, Math.max(2 * interval, stepping));
 		if (pace === "fast" || pace === "connected" || since < 0) return interval;
+		if (pace === "background" && !this.presence.online && this.invite()) return unusedInviteWait(Date.now() - this.awaitingSince, interval);
 		return Math.min(interval, Math.max(2 * this.intervals.fast, since));
 	}
 	/**
@@ -6069,13 +6203,17 @@ var LinkSession = class {
 	watching() {
 		return Date.now() < this.watchUntil && this.rtcSignal === null && !(this.presence.online && this.presence.lastPacketAt > this.watchFrom);
 	}
+	/** A contact never seen, whose invite was sent lately (`AWAITING_PEER_MS`): its join is due. */
+	awaitingPeer() {
+		return this.presence.lastPacketAt === 0 && Date.now() - this.awaitingSince < 6e5;
+	}
 	/** How urgently this link looks right now. */
 	pace() {
 		if (Date.now() < this.stalledUntil) return "fast";
 		if (this.connected) return "connected";
 		if (Date.now() < this.fastPollUntil) return "fast";
 		if (Date.now() < this.watchUntil) return "active";
-		if (!this.active && this.presence.lastPacketAt === 0 && Date.now() - this.awaitingSince < 6e5) return "active";
+		if (!this.active && this.awaitingPeer()) return "active";
 		if (!this.active) return "background";
 		return Date.now() - this.lastActivity > 6e4 ? "idle" : "active";
 	}
@@ -6132,7 +6270,9 @@ var LinkSession = class {
 		}, this.encKey);
 		const started = Date.now();
 		try {
-			const options = rtcSignal && rtcSignal !== this.rtcSignalOut ? { signal: true } : this.watching() ? { watch: true } : upkeep && this.connected ? { background: true } : void 0;
+			const awaited = this.connected || this.presence.online || this.sentBuffer.length > 0 || this.callSignal !== null || this.awaitingPeer();
+			const takesBack = !rtcSignal && this.rtcSignalOut !== null;
+			const options = rtcSignal && rtcSignal !== this.rtcSignalOut ? { signal: true } : this.watching() ? { watch: true } : upkeep && (this.connected || takesBack) || !rtcSignal && !awaited ? { background: true } : void 0;
 			await this.transport.publish(this.identity, built.records, options);
 		} catch (error) {
 			const ms = Date.now() - started, waiting = isDiscoveryBudgetError(error);
@@ -6437,7 +6577,9 @@ var ICE_GATHERING_TIMEOUT_MS = 5e3;
 * settle); where they do not, every offer of a first pairing waited the full 5 s, twice when the inviter offered too
 * (One's e2e runs: 13 offers of 89 at 5 s, 9 more at 1.3-3 s, 2026-10-05). An offer without one still connects to most
 * contacts (their checks learn this side's address from its own); behind a restricted NAT on the contact's side it may
-* not, and the next offer of the chat then waits as long as it takes (`fullGather`).
+* not, and the next offer of the chat then waits as long as it takes (`fullGather`). An answer is bounded the same way:
+* it waited the full 5 s, and two CLI daemons whose STUN server swallowed every request went live 10 s after the offer
+* rather than 2 s (calls bug hunt, 2026-10-12).
 */
 var OFFER_HOST_GATHER_MS = 2e3;
 /**
@@ -6447,6 +6589,14 @@ var OFFER_HOST_GATHER_MS = 2e3;
 var GATHER_STALL_MS = 3e3;
 /** How long a connection may stay `disconnected` before it is given up. */
 var DISCONNECT_GRACE_MS = 12e3;
+/**
+* The same race a moment later: setRemoteDescription resolves, and the connection closes right after it (8 ms on a
+* loaded core). A connection that ends within this long of its answer going in was refused too: no network fails one
+* that soon (ICE gives up after tens of seconds), so it says nothing about direct connections (`DirectEvidence`).
+* Taken for a network that lets none through, an edge between two CLIs left WebRTC for the run, and a member whose
+* app has WebRTC alone (one from before native group links) was never reached again (groupCompat, 2026-10-12).
+*/
+var ANSWER_REFUSED_AFTER_MS = 1e3;
 /** An offer this close to the end of the offerer's attempt is not answered again: the new answer would come too late. */
 var REANSWER_MARGIN_MS = 15e3;
 /**
@@ -6478,12 +6628,13 @@ var DataLink = class {
 	pc = null;
 	myOfferTs = 0;
 	/**
-	* An offer of this side's that went without a public candidate came to nothing (it was answered, and no path
-	* connected): the next one waits for its STUN servers as long as it takes (`ICE_GATHERING_TIMEOUT_MS`).
+	* An offer or answer of this side's that went without a public candidate came to nothing (both descriptions were
+	* exchanged, and no path connected): the next one waits for its STUN servers as long as it takes
+	* (`ICE_GATHERING_TIMEOUT_MS`).
 	*/
 	fullGather = false;
-	/** The offer out has no public candidate (as it went: the connection's description gains any that come later). */
-	offerLacksPublic = false;
+	/** The offer or answer out has no public candidate (as it went: the connection's description gains any that come later). */
+	sentLacksPublic = false;
 	lastSignalTs = 0;
 	/** The peer's description as this connection was given it: Chrome shows it as `remoteDescription` only once applied. */
 	remoteSdp = null;
@@ -6529,7 +6680,7 @@ var DataLink = class {
 				this.options.setFastPoll(true, true);
 			}
 			this.myOfferTs = Date.now();
-			this.offerLacksPublic = !PUBLIC_CANDIDATE.test(pc.localDescription?.sdp ?? "");
+			this.sentLacksPublic = !PUBLIC_CANDIDATE.test(pc.localDescription?.sdp ?? "");
 			const signal = {
 				t: "o",
 				ts: this.myOfferTs,
@@ -6635,9 +6786,12 @@ var DataLink = class {
 		this.reset();
 		if (evidence) this.options.onDirect?.(evidence);
 	}
-	/** This side's offer went with no public candidate, was answered, and came to nothing: the next offer gathers for as long as it takes. */
+	/**
+	* This side's offer went with no public candidate and was answered, or its answer went with none, and it came to
+	* nothing: the next offer or answer gathers for as long as it takes.
+	*/
 	noteNoPublic(ended) {
-		if (ended && this.myOfferTs && this.offerLacksPublic && this.state === "connecting") this.fullGather = true;
+		if (ended && (this.myOfferTs || this.answered) && this.sentLacksPublic && this.state === "connecting") this.fullGather = true;
 	}
 	/**
 	* What this attempt says about direct connections if it ends now without opening: nothing unless both descriptions
@@ -6652,17 +6806,22 @@ var DataLink = class {
 	/**
 	* The attempt on this connection failed (it timed out, ICE failed or closed, its channel closed). An answer the
 	* offerer may not have read yet is made again for the same offer while it still stands (`REANSWERS`); anything
-	* else goes back to idle.
+	* else goes back to idle. `byConnection`: the connection said so itself, rather than a timer of this link's.
 	*/
-	failed() {
+	failed(byConnection = false) {
 		if (this.state === "offering" && this.remoteSdp) {
 			this.answerRefused("failed");
 			return;
 		}
+		if (byConnection && this.state === "connecting" && this.myOfferTs && Date.now() - this.connectingSince < ANSWER_REFUSED_AFTER_MS) {
+			this.answerRefused("failed");
+			return;
+		}
 		const answered = this.state === "connecting" ? this.answered : null;
 		const left = answered ? CONNECT_TIMEOUT_MS - (Date.now() - answered.at) : 0;
-		const evidence = this.directEvidence();
-		this.noteNoPublic(true);
+		const givenUp = !!answered && this.options.offerStanding?.(answered.offer.ts) === false;
+		const evidence = givenUp ? null : this.directEvidence();
+		this.noteNoPublic(!givenUp);
 		if (answered && answered.again < 2 && left > REANSWER_MARGIN_MS && this.options.offerStanding?.(answered.offer.ts)) {
 			answered.again++;
 			traceLink(this.options.myPubKeyZ32, "reanswer", {
@@ -6703,6 +6862,7 @@ var DataLink = class {
 				await pc.setLocalDescription(await pc.createAnswer());
 			});
 			if (!pc) return;
+			this.sentLacksPublic = !PUBLIC_CANDIDATE.test(pc.localDescription?.sdp ?? "");
 			const signal = {
 				t: "a",
 				ts: Date.now(),
@@ -6732,7 +6892,7 @@ var DataLink = class {
 			await waitForIceGathering(pc, ICE_GATHERING_TIMEOUT_MS, {
 				stallMs: GATHER_STALL_MS,
 				settleMs: 150,
-				...offer && !this.fullGather ? { hostBoundMs: OFFER_HOST_GATHER_MS } : {}
+				...!this.fullGather ? { hostBoundMs: OFFER_HOST_GATHER_MS } : {}
 			});
 			if (this.pc !== pc) return null;
 			const ms = Date.now() - gathering;
@@ -6779,7 +6939,7 @@ var DataLink = class {
 			tracePair(this.options.myPubKeyZ32, pc);
 		});
 		dc.addEventListener("close", () => {
-			if (this.pc === pc) this.failed();
+			if (this.pc === pc) this.failed(true);
 		});
 		pc.addEventListener("connectionstatechange", () => {
 			if (this.pc !== pc) return;
@@ -6788,7 +6948,7 @@ var DataLink = class {
 				if (pc.connectionState === "connected") this.options.onDisconnected?.(false);
 			}
 			this.disconnectTimer = null;
-			if (pc.connectionState === "failed" || pc.connectionState === "closed") this.failed();
+			if (pc.connectionState === "failed" || pc.connectionState === "closed") this.failed(true);
 			else if (pc.connectionState === "disconnected") {
 				if (this.state === "open") this.options.onDisconnected?.(true);
 				this.disconnectTimer = setTimeout(() => {
@@ -8705,11 +8865,6 @@ var VIDEO_LIMITS = {
 	/** Pixels on either side (8K and a bit). */
 	maxEdge: 16384
 };
-/**
-* Video a player may be handed as it is. None of these runs anything in the page's origin, so received bytes
-* of these types are served with their type (see `safeBlobType`): WebKit will not play what is typed as bytes.
-*/
-var PLAYABLE_VIDEO = /^video\/(mp4|webm|quicktime|ogg|x-m4v)$/;
 /** Whether a file is a video, by its type: shown in a video bubble whether or not it came with a description. */
 function isVideoMime(mime) {
 	return mime.split(";")[0].trim().toLowerCase().startsWith("video/");
@@ -8903,18 +9058,6 @@ function formatFileSize(bytes) {
 	}
 	return `${value.toFixed(1)} ${units[unit]}`;
 }
-/** Raster images a UI may show inline. SVG is left out on purpose: it can carry scripts. */
-var PREVIEWABLE_IMAGE = /^image\/(png|jpe?g|gif|webp)$/;
-/**
-* The type received bytes are served with. The peer picks the announced type,
-* and a blob: URL typed text/html or image/svg+xml would run in the app's
-* origin, so anything but a previewable image or playable audio or video is opaque bytes.
-* Audio and video keep their type because WebKit will not play what is typed as bytes.
-*/
-function safeBlobType(mime) {
-	const clean = sanitizeMime(mime);
-	return PREVIEWABLE_IMAGE.test(clean) || PLAYABLE_AUDIO.test(clean) || PLAYABLE_VIDEO.test(clean) ? clean : "application/octet-stream";
-}
 var FileTransfers = class {
 	channel;
 	events;
@@ -9355,6 +9498,7 @@ var DhtDelivery = class DhtDelivery {
 	fastUntil = 0;
 	live = false;
 	active = false;
+	startedAt = Date.now();
 	/** The next read was asked for (a refresh, a fresh packet of the contact): it is not a background one. */
 	urgent = false;
 	/** Reads left that are signaling: the contact is leaving DHT only, and the live link waits on them (`expect`). */
@@ -9426,6 +9570,14 @@ var DhtDelivery = class DhtDelivery {
 		};
 	}
 	/**
+	* This side joined, and its inviter never answered (`DhtDeliveryState.unanswered`): no envelope of its newer than the
+	* one that pinned it, none sealed to this side, no text confirmed, never live (as `sealedToAnother` asks too).
+	*/
+	get unanswered() {
+		const pinnedAt = this.state.unanswered;
+		return pinnedAt !== void 0 && this.state.peerSequence <= pinnedAt && !this.state.peerPinned && !this.state.confirmed && !this.state.wasLive && !this.live;
+	}
+	/**
 	* Something signed by a participation key other than the pinned one came in over the chat's invite-derived keys (this
 	* mailbox, the link's signals, a connection to an endpoint whose address a copy of the invite could read): ignored,
 	* and said in the view as a passive warning.
@@ -10134,6 +10286,7 @@ var DhtDelivery = class DhtDelivery {
 		}
 		if (message !== null && (!Array.isArray(message) || message.length !== 3 || typeof message[0] !== "string" || !ID$2.test(message[0]) || !Number.isSafeInteger(message[1]) || message[1] <= 0 || message[1] > issued + 3e4 || typeof message[2] !== "string" || utf8Encode(message[2]).length > 256 || expires - issued > 3e5)) return "none";
 		if (receipt !== null && (typeof receipt !== "string" || !ID$2.test(receipt))) return "none";
+		const unanswered = !this.options.credentials.peerKey && !!this.options.credentials.expectedPeerKey && !sender && !this.live;
 		await this.options.pin(author);
 		this.options.credentials.peerKey = author;
 		this.options.credentials.requireSignedSignals = true;
@@ -10184,6 +10337,7 @@ var DhtDelivery = class DhtDelivery {
 			receipt: nextReceipt,
 			confirmed,
 			...peerPinned && { peerPinned },
+			...unanswered && { unanswered: sequence },
 			pending: confirmed && this.state.pending?.message[0] === confirmed ? void 0 : this.state.pending,
 			...newest > (this.state.reactionsTaken ?? 0) && { reactionsTaken: newest }
 		});
@@ -10298,11 +10452,23 @@ var DhtDelivery = class DhtDelivery {
 	get pollMs() {
 		if (this.options.pollMs) return this.options.pollMs;
 		const now = Date.now();
+		const unused = this.unusedInviteAge(now);
+		if (unused !== void 0 && !this.active && now >= this.fastUntil) return unusedInviteWait(unused, this.mode === "dht" ? DHT_POLL_MS : STREAM_POLL_MS);
 		if (this.mode === "dht" || this.state.peerMode === "dht" && now < this.leavingUntil || now < this.fastUntil) return DHT_POLL_MS;
 		if (this.live) return LIVE_POLL_MS;
 		if (this.state.pending && this.state.pending.expires > now) return DHT_POLL_MS;
 		return this.active ? ACTIVE_DHT_POLL_MS : STREAM_POLL_MS;
 	}
+	/**
+	* How long ago this side's invite was made (or joined), while nobody used it (or its inviter never answered,
+	* `unanswered`) and it is no longer awaited (`AWAITING_PEER_MS`).
+	*/
+	unusedInviteAge(now) {
+		const madeAt = this.options.inviteMadeAt;
+		if (madeAt === void 0 || (this.options.credentials.peerKey || this.state.peerSequence) && !this.unanswered) return void 0;
+		const age = now - Math.min(madeAt, this.startedAt);
+		return age >= 6e5 ? age : void 0;
+	}
 	schedule() {
 		if (!this.running || this.ticking) return;
 		if (this.timer) clearTimeout(this.timer);
@@ -13431,6 +13597,8 @@ function readManifest(meta, loopback = false) {
 */
 var OFFER_EXTENSIONS = ["ping/1"];
 var MAX_HANDSHAKE_BYTES = 4096;
+/** One frame from the peer, at most (UTF-16 units for text, bytes for binary): a bigger one breaks the protocol. */
+var SESSION_FRAME_MAX = 61440;
 /**
 * Frames received and not handled yet, at most: their count and their size together. Frames are handled one at a time,
 * each awaited (a group frame is decrypted, checked and stored before the next), and the peer sends at the network's
@@ -13441,7 +13609,7 @@ var MAX_HANDSHAKE_BYTES = 4096;
 */
 var SESSION_RECEIVE_PENDING = {
 	frames: 1024,
-	bytes: 3932160
+	bytes: 64 * SESSION_FRAME_MAX
 };
 var KEY = /^[ybndrfg8ejkmcpqxot1uwisza345h769]{52}$/;
 var NONCE$1 = /^[A-Za-z0-9_-]{43}$/;
@@ -13792,6 +13960,9 @@ var PairedHttp = class {
 				return channel.bufferedAmount;
 			},
 			drained: () => channel.drained(),
+			get sendBudget() {
+				return channel.sendBudget;
+			},
 			close: () => {},
 			onMessage: null,
 			onClose: null
@@ -13836,6 +14007,11 @@ var SERVICES_CAPABILITY = "services/1";
 * confirmed byte, checked by digest (`pf-offer` … frames, `chatFiles.ts`). Without it, files/2 and 100 MiB.
 */
 var FILES_CAPABILITY = "files/3";
+/**
+* A file's bytes as binary messages (WISP 501 § files/4): beside `files/3`, on a session whose channel carries binary
+* messages, a chunk travels as it is (`encodeFileData`, `chatFiles.ts`) and not as base64url text in a `pf-data` frame.
+*/
+var FILES_BINARY_CAPABILITY = "files/4";
 /** The typing indicator: `paired-typing` frames on this session, 1:1 chats only (WISP 401 § Typing, `pairedTyping.ts`). */
 var TYPING_CAPABILITY = "typing/1";
 /** Reactions to messages: `paired-reaction` frames on this session, 1:1 chats only (WISP 401 § Reactions, `reactions.ts`). */
@@ -13875,6 +14051,7 @@ var KNOWN_SESSION_CAPABILITIES = [
 	CALLS_CAPABILITY,
 	SERVICES_CAPABILITY,
 	FILES_CAPABILITY,
+	FILES_BINARY_CAPABILITY,
 	TYPING_CAPABILITY,
 	REACTIONS_CAPABILITY,
 	EDIT_CAPABILITY,
@@ -13971,6 +14148,8 @@ var SessionCapabilities = class {
 * be matched across a person's chats; it travels only inside the encrypted session.
 */
 var APP_FRAME = "paired-app";
+/** The largest `d`, as compact UTF-8 JSON. The session's 60 KiB cap on any frame still holds above it. */
+var APP_DATA_MAX_BYTES = 32768;
 var DOMAIN = "ghostly-apps/1";
 var APP_ID = /^[A-Za-z0-9_-]{22}$/;
 /** Semantic versioning 2.0.0, as a manifest's `version` is. */
@@ -14810,6 +14989,11 @@ var FILE_LIMITS = {
 	chunkBytes: 16384,
 	/** Bytes a sender has sent and not seen confirmed: throughput is this per round trip. */
 	windowBytes: 1048576,
+	/**
+	* Bytes all of a chat's files have sent and not seen confirmed, together. Three files' windows at once were 3 MiB, and
+	* as base64 text past what a session's receive queue holds (`SESSION_RECEIVE_PENDING`, 3.75 MiB).
+	*/
+	chatWindowBytes: 2097152,
 	/** A receiver asks its person before taking a file larger than this. */
 	askAboveBytes: 26214400,
 	/** Files taken without asking, per contact, while stored. Past it, every file is asked about. */
@@ -14878,6 +15062,37 @@ function transferStalled(record, movedAt, restored, now) {
 }
 var key = (direction, id) => `${direction}:${id}`;
 var isInt$1 = (value, max = Number.MAX_SAFE_INTEGER) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && value <= max;
+var FILE_DATA_OFFSET_BYTES = 8;
+/** The binary message for the bytes of file `id` at `offset`. Throws on what no receiver would take. */
+function encodeFileData(id, offset, data) {
+	if (!ID.test(id) || !isInt$1(offset) || !data.length || data.length > FILE_LIMITS.chunkBytes) throw new Error("Invalid file data");
+	const head = 2 + id.length;
+	const out = new Uint8Array(head + FILE_DATA_OFFSET_BYTES + data.length);
+	out[0] = 4;
+	out[1] = id.length;
+	for (let i = 0; i < id.length; i++) out[2 + i] = id.charCodeAt(i);
+	const view = new DataView(out.buffer);
+	view.setUint32(head, Math.floor(offset / 2 ** 32));
+	view.setUint32(head + 4, offset % 2 ** 32);
+	out.set(data, head + FILE_DATA_OFFSET_BYTES);
+	return out;
+}
+/** What a binary message from the contact says, or null when it is not a well-formed file data message. `data` is a view of `message`. */
+function decodeFileData(message) {
+	if (message.length < 2 || message[0] !== 4) return null;
+	const head = 2 + message[1], body = head + FILE_DATA_OFFSET_BYTES;
+	if (message.length <= body || message.length - body > FILE_LIMITS.chunkBytes) return null;
+	const id = String.fromCharCode(...message.subarray(2, head));
+	if (!ID.test(id)) return null;
+	const view = new DataView(message.buffer, message.byteOffset, message.byteLength);
+	const high = view.getUint32(head);
+	if (high > 2097151) return null;
+	return {
+		id,
+		offset: high * 2 ** 32 + view.getUint32(head + 4),
+		data: message.subarray(body)
+	};
+}
 /** What a refusal means to the sender's person. */
 function refusalText(why, room) {
 	switch (why) {
@@ -14914,6 +15129,10 @@ function refusalText(why, room) {
 var ChatFiles = class {
 	host;
 	entries = /* @__PURE__ */ new Map();
+	/** Files sending that may have bytes not confirmed yet: what `inFlight` adds up (the rest are left out as it goes). */
+	moving = /* @__PURE__ */ new Set();
+	/** Files that stopped sending for the chat's window alone: they go on once another's bytes are confirmed. */
+	held = /* @__PURE__ */ new Set();
 	attached = false;
 	peerRoomValue = null;
 	constructor(host) {
@@ -14973,6 +15192,15 @@ var ChatFiles = class {
 	send(frame) {
 		return this.attached && this.host.send(frame);
 	}
+	sendData(id, offset, data) {
+		if (!this.host.sendData) return this.send({
+			t: "pf-data",
+			id,
+			offset,
+			data: toBase64Url(data)
+		});
+		return this.attached && this.host.sendData(id, offset, data);
+	}
 	/** A session that agreed files/3 is open: say what fits here, then offer again what is not finished. */
 	attach() {
 		this.attached = true;
@@ -14991,6 +15219,8 @@ var ChatFiles = class {
 		if (!this.attached) return;
 		this.attached = false;
 		this.peerRoomValue = null;
+		this.moving.clear();
+		this.held.clear();
 		for (const entry of this.entries.values()) {
 			if (entry.out) {
 				entry.out.generation++;
@@ -15114,10 +15344,34 @@ var ChatFiles = class {
 		const at = offset - out.block.start;
 		return out.block.bytes.subarray(at, at + length);
 	}
-	shouldPump(entry) {
+	/** Whether this file's own window lets it send more. */
+	fileMayPump(entry) {
 		const { record } = entry, out = entry.out;
 		return this.attached && record.state === "active" && out.next < record.file.size && out.next - record.confirmed < FILE_LIMITS.windowBytes;
 	}
+	shouldPump(entry) {
+		return this.fileMayPump(entry) && this.inFlight() < FILE_LIMITS.chatWindowBytes;
+	}
+	/** Bytes this chat's files sent and have not seen confirmed. */
+	inFlight() {
+		let bytes = 0;
+		for (const entry of this.moving) {
+			const out = entry.out, { record } = entry;
+			if (!out || record.state !== "active" || out.next <= record.confirmed) {
+				this.moving.delete(entry);
+				continue;
+			}
+			bytes += out.next - record.confirmed;
+		}
+		return bytes;
+	}
+	/** Bytes were confirmed, or a file stopped sending: the files the chat's window held go on, before the one that freed it. */
+	wakeHeld() {
+		for (const entry of [...this.held]) {
+			this.held.delete(entry);
+			this.pump(entry);
+		}
+	}
 	/**
 	* Whether the next `length` bytes go. Within the file's size they always do; past it the receiver is having parts
 	* sent again, which nothing it says bounds, so this side does.
@@ -15148,17 +15402,13 @@ var ChatFiles = class {
 					this.end(entry, "failed", "Your contact asked for the same part of this file too many times");
 					break;
 				}
-				if (!this.send({
-					t: "pf-data",
-					id: entry.record.id,
-					offset,
-					data: toBase64Url(chunk)
-				})) {
+				if (!this.sendData(entry.record.id, offset, chunk)) {
 					refused = true;
 					break;
 				}
 				out.next = offset + chunk.length;
 				out.sent += chunk.length;
+				this.moving.add(entry);
 			}
 		} catch (error) {
 			if (generation === out.generation) {
@@ -15173,7 +15423,7 @@ var ChatFiles = class {
 			if (generation === out.generation && this.shouldPump(entry)) {
 				if (refused) out.wake = setTimeout(() => void this.pump(entry), FILE_LIMITS.sendRetryMs);
 				else this.pump(entry);
-			}
+			} else if (generation === out.generation && this.fileMayPump(entry)) this.held.add(entry);
 		}
 	}
 	async sendSum(entry) {
@@ -15205,7 +15455,7 @@ var ChatFiles = class {
 		return [...this.entries.values()].filter((e) => e.record.direction === "in" && e.record.state === "asking").length;
 	}
 	activeIncoming(except) {
-		return [...this.entries.values()].filter((e) => e !== except && e.record.direction === "in" && (e.record.state === "active" || e.record.state === "verifying")).length;
+		return [...this.entries.values()].filter((e) => e !== except && e.record.direction === "in" && (e.record.state === "active" || e.record.state === "verifying" || e.in?.starting)).length;
 	}
 	/**
 	* Removes what this side stored of an incoming file that ends here. Through its target, opened now if need be: after
@@ -15232,9 +15482,15 @@ var ChatFiles = class {
 		}
 		return incoming.target;
 	}
-	/** An accepted file goes when a session is open and fewer than three others arrive at once. */
+	/**
+	* An accepted file goes when a session is open and fewer than three others arrive at once. One whose target is still
+	* being opened counts among the three: counted only once active, every file offered or queued meanwhile went too, and
+	* the windows of ten files and more at once overflowed the session's receive queue.
+	*/
 	startIncoming(entry) {
 		if (!this.attached || transferEnded(entry.record) || entry.record.state === "asking" || entry.record.state === "paused" && entry.record.pausedBy === "me") return;
+		const incoming = entry.in;
+		if (incoming.starting) return;
 		if (this.activeIncoming(entry) >= FILE_LIMITS.maxActiveIncoming) {
 			if (entry.record.state !== "queued") {
 				entry.record.state = "queued";
@@ -15247,9 +15503,13 @@ var ChatFiles = class {
 			});
 			return;
 		}
+		incoming.starting = true;
 		this.target(entry).then(() => {
-			if (transferEnded(entry.record) || !this.attached) return;
-			if (entry.record.state === "paused" && entry.record.pausedBy === "me") return;
+			incoming.starting = false;
+			if (transferEnded(entry.record) || !this.attached || entry.record.state === "paused" && entry.record.pausedBy === "me") {
+				this.startNext();
+				return;
+			}
 			entry.record.state = "active";
 			entry.record.pausedBy = void 0;
 			entry.in.gapAt = void 0;
@@ -15262,12 +15522,14 @@ var ChatFiles = class {
 			entry.in.heardAt = this.now();
 			this.armNudge(entry);
 		}, (error) => {
+			incoming.starting = false;
 			this.end(entry, "failed", `Could not store the file: ${error instanceof Error ? error.message : String(error)}`);
 			this.send({
 				t: "pf-refuse",
 				id: entry.record.id,
 				why: "no-room"
 			});
+			this.startNext();
 		});
 	}
 	/** The next file waiting its turn, once one ends. */
@@ -15506,7 +15768,9 @@ var ChatFiles = class {
 		if (record.state !== "active" || !incoming.target) return;
 		incoming.heardAt = this.now();
 		const { offset, data } = frame;
-		if (!isInt$1(offset) || typeof data !== "string" || !data.length || data.length > Math.ceil(FILE_LIMITS.chunkBytes * 4 / 3) || !DATA.test(data)) return;
+		const binary = data instanceof Uint8Array;
+		if (!isInt$1(offset) || !(binary || typeof data === "string") || !data.length) return;
+		if (!binary && (data.length > Math.ceil(FILE_LIMITS.chunkBytes * 4 / 3) || !DATA.test(data))) return;
 		if (offset < incoming.written) {
 			if (incoming.stored === incoming.written) this.send({
 				t: "pf-got",
@@ -15526,7 +15790,7 @@ var ChatFiles = class {
 			}
 			return;
 		}
-		const bytes = fromBase64Url(data);
+		const bytes = binary ? data : fromBase64Url(data);
 		if (!bytes.length || bytes.length > FILE_LIMITS.chunkBytes || offset + bytes.length > record.file.size) return;
 		incoming.written += bytes.length;
 		const target = incoming.target;
@@ -15711,6 +15975,7 @@ var ChatFiles = class {
 				record.state = "active";
 				record.pausedBy = record.waitingFor = void 0;
 				this.changed(outgoing);
+				this.wakeHeld();
 				if (record.confirmed === record.file.size) this.sendSum(outgoing);
 				else {
 					this.armStall(outgoing);
@@ -15730,11 +15995,13 @@ var ChatFiles = class {
 					record.waitingFor = frame.why === "busy" ? "busy" : "consent";
 				}
 				this.changed(outgoing);
+				this.wakeHeld();
 				return;
 			case "pf-got":
 				if (!isInt$1(frame.offset) || frame.offset <= record.confirmed || frame.offset > out.next) return;
 				record.confirmed = frame.offset;
 				this.changed(outgoing, true);
+				this.wakeHeld();
 				if (record.confirmed === record.file.size) this.sendSum(outgoing);
 				else {
 					this.armStall(outgoing);
@@ -15764,6 +16031,8 @@ var ChatFiles = class {
 			clearTimeout(entry.out.wake);
 			entry.out.block = void 0;
 			entry.out.source = void 0;
+			this.moving.delete(entry);
+			this.held.delete(entry);
 		}
 		if (entry.in) {
 			const incoming = entry.in;
@@ -15773,6 +16042,7 @@ var ChatFiles = class {
 			});
 		}
 		this.changed(entry);
+		if (entry.out) this.wakeHeld();
 	}
 	entry(direction, id) {
 		const entry = this.entries.get(key(direction, id));
@@ -15821,6 +16091,7 @@ var ChatFiles = class {
 			this.startNext();
 		}
 		this.changed(entry);
+		if (entry.out) this.wakeHeld();
 	}
 	resume(direction, id) {
 		const entry = this.entry(direction, id), { record } = entry;
@@ -16439,6 +16710,8 @@ var CarriedTransport = class {
 	/** My last packet while the edge is down: what a member that just became reachable is handed. */
 	mine = null;
 	lastTimestamp = 0n;
+	/** The date each packet `stamp` signed carries: the relays' transport takes it rather than check the signature again. */
+	dated = /* @__PURE__ */ new WeakMap();
 	/** My newest packet, wherever it went: what the edge hands the member over itself once it is ready (`linkReady`). */
 	newest = null;
 	/** The newest packet of the member's that came through a carrier, and the timestamp of the one a read last returned. */
@@ -16518,7 +16791,9 @@ var CarriedTransport = class {
 	stamp(identity, records) {
 		const now = BigInt(Date.now()) * 1000n;
 		this.lastTimestamp = now > this.lastTimestamp ? now : this.lastTimestamp + 1n;
-		return createRelayPayload(identity, records, this.lastTimestamp);
+		const payload = createRelayPayload(identity, records, this.lastTimestamp);
+		this.dated.set(payload, this.lastTimestamp);
+		return payload;
 	}
 	/**
 	* The relays get the very packet members carried or the edge itself handed over, byte for byte, where the transport
@@ -16528,7 +16803,11 @@ var CarriedTransport = class {
 	* its restart and then wait 40 s for (7 of 16 goodbyes on the admin in the member-back runs, 1 of 16 on dev, 2026-10-03).
 	*/
 	toRelays(identity, records, payload, options) {
-		return this.inner.publishPayload ? this.inner.publishPayload(identity.pubKeyZ32, payload, options) : this.inner.publish(identity, records, options);
+		const signedAt = this.dated.get(payload);
+		return this.inner.publishPayload ? this.inner.publishPayload(identity.pubKeyZ32, payload, signedAt === void 0 ? options : {
+			...options,
+			signedAt
+		}) : this.inner.publish(identity, records, options);
 	}
 	/**
 	* The packet the relays just took, handed to the member over the edge itself while it is up. An edge up reads nothing
@@ -16673,8 +16952,12 @@ var GROUP_FILE_LIMITS = {
 	heardAhead: 256,
 	/** Message ids in one `group-have`. */
 	haveIds: 32,
-	/** A private group's `group-have` goes on an edge at most this often; a community's, from a member, every `communityHaveEveryMs`. */
-	haveEveryMs: 1e4,
+	/**
+	* `group-have` frames a private group's edge takes in `haveWindowMs`: what is to say is gathered for a second, then
+	* goes. A community's, from a member, goes every `communityHaveEveryMs`.
+	*/
+	haveFrames: 10,
+	haveWindowMs: 1e4,
 	communityHaveEveryMs: 6e4,
 	/**
 	* How long a want waits for an offer before the next holder is asked; a transfer that does not move for as long is
@@ -17078,6 +17361,14 @@ var PACKET_TRANSPORTS_FAST_ATTEMPTS = 3;
 var DHT_PIN_GRACE_MS = 1e4;
 /** Back after a restart (`resume`), dials wait this long at most for the native endpoint that carried the chat to start. */
 var RESUME_WAIT_MS = 1e4;
+/**
+* A dial of the contact's that meets such a session waits this long for that session to answer a ping. It answers when
+* the dials crossed (the contact holds this side's dial too); it does not when the contact's app ended since and is
+* back: its dial then takes over. Refused outright, that dial left the contact waiting for the dead session's end, 16.6
+* to 18.9 s (CLI daemons over HyperDHT, the contact killed 1 to 3 s after this side's knock, 5 of 5). A round trip is
+* 7 ms on loopback and under 0.5 s over a relayed Iroh.
+*/
+var CROSSED_PROBE_MS = 1500;
 /** A WebRTC attempt under way, not yet open: what a member's packet saying it has no WebRTC ends (`peerPacketTransports`). */
 var WEBRTC_ATTEMPT = /* @__PURE__ */ new Set([
 	"offering",
@@ -17199,6 +17490,24 @@ var HANDLED_WAIT_MS = 1e4;
 */
 var WAKE_LOST_MS = 1e4;
 /**
+* What files/3 may hold on a session's channel (WISP 501, Backpressure): a quarter of its send budget (native and iroh
+* channels throw past 120 KiB), or the high water mark of a WebRTC channel, which has none.
+*/
+function filesCap(channel) {
+	return channel.sendBudget ? channel.sendBudget / 4 : LIMITS.sendHighWaterMark;
+}
+/**
+* How long after files last wrote on a channel, or last waited for room on it, an app's data keeps its own quarter above
+* their line (WISP 1200 § In a chat): a file waiting for `pf-got` holds its share meanwhile.
+*/
+var FILES_IN_USE_MS = 2e3;
+/**
+* How far an app's data may get ahead of a file's bytes while the file waits for room on the channel (WISP 1200 § In a
+* chat): a frame goes only while the app has sent less than this more than the file since. A small frame (a Chess move)
+* still goes at once; one streaming at its limit gets about half the link, and the file the other half.
+*/
+var APP_AHEAD_OF_FILES = 16384;
+/**
 * A `paired-message` frame. The preview (`pv`) is left out when the frame would pass `MAX_PAIRED_MESSAGE_FRAME`
 * with it: the text matters, the card does not. A reply (`r`, WISP 401 § Replies) is a few hundred bytes at most
 * and always goes, and so does a forwarded message's hop count (`fw`, WISP 401 § Forwards) and a status card (`sc`,
@@ -17228,6 +17537,16 @@ function pairedMessageFrame(id, ts, m, preview, reply, forwarded, card) {
 	});
 	return withPreview.length <= 57344 ? withPreview : plain;
 }
+/** A text whose `paired-message` frame would pass what a session takes: it never arrives, and is refused at send. */
+var PAIRED_FRAME_TOO_LARGE = "Message too long once encoded. Shorten it or send it as a file.";
+/**
+* The `paired-message` frame of this text fits a session (`SESSION_FRAME_MAX`, UTF-16 units of the JSON). Within 16 KiB
+* of UTF-8 a text can still pass it: JSON writes each control character as six (`\u0001`). The preview is left out,
+* as the frame drops one that does not fit.
+*/
+function pairedMessageFits(ts, m, reply, forwarded, card) {
+	return pairedMessageFrame("A".repeat(22), ts, m, void 0, reply, forwarded, card).length <= SESSION_FRAME_MAX;
+}
 /**
 * A native descriptor from the contact's capability record against the one known (a session's, or an older record's).
 * The record carries only how to dial, never an address: the Iroh endpoint id and the relay it is homed on, the
@@ -17546,6 +17865,9 @@ var GhostLink = class {
 			});
 			options.events?.onPairingProgress?.(progress);
 		}) : null;
+		const invite = !!options.pairingProgress && !!options.pairing && !options.pairing.credentials.peerKey;
+		let unanswered = options.dht?.state?.unanswered !== void 0;
+		const backsOff = invite || unanswered;
 		this.dht = options.params.profile && options.pairing && options.dht ? new DhtDelivery({
 			params: options.params,
 			mode: this.deliveryMode,
@@ -17555,6 +17877,7 @@ var GhostLink = class {
 			save: options.dht.save,
 			pollMs: options.dht.pollMs,
 			firstControlAfterMs: options.dht.firstControlAfterMs,
+			...backsOff && { inviteMadeAt: options.madeAt ?? Date.now() },
 			capsRev: options.dht.capsRev,
 			peerCapsRev: options.dht.peerCapsRev,
 			peerAcceptsText: options.dht.peerAcceptsText,
@@ -17570,6 +17893,7 @@ var GhostLink = class {
 			},
 			pin: async (key) => {
 				await options.pairing.pinPeer(key, true);
+				if (invite) this.session.lookNow();
 				if (this.isDataLinkOpen || !this.tracker || this.tracker.done) return;
 				if (this.deliveryMode === "dht") {
 					this.tracker.onDht("chosen");
@@ -17612,6 +17936,9 @@ var GhostLink = class {
 			},
 			changed: (view) => {
 				options.events?.onDhtDelivery?.(view);
+				const stillUnanswered = this.dht.unanswered;
+				if (unanswered && !stillUnanswered) this.session.lookNow();
+				unanswered = stillUnanswered;
 				if (view.inviteTaken) this.tracker?.failed("taken", false, INVITE_TAKEN);
 				else this.tracker?.untaken();
 				this.streamBlockChanged();
@@ -17640,6 +17967,7 @@ var GhostLink = class {
 			lastSeenTimestamp: options.lastSeenTimestamp,
 			pollIntervals: options.pollIntervals,
 			awaitingSince: options.madeAt,
+			...backsOff && { invite: () => !options.pairing.credentials.peerKey || !!this.dht?.unanswered },
 			getServices: options.getServices,
 			firstPublish: options.firstPublish ?? (this.tracker && options.pairingProgress?.role === "joiner" && options.rtcAvailable !== false || this.resuming ? "after-first-poll" : "at-start"),
 			events: {
@@ -18152,11 +18480,11 @@ var GhostLink = class {
 	}
 	start() {
 		if (this.saidTransports) this.publishPacketTransports();
-		if (this.deliveryMode !== "dht") this.session.start();
 		if (this.resuming && this.deliveryMode !== "dht") {
 			this.session.expectPeer();
 			this.resumeWaitUntil = Date.now() + RESUME_WAIT_MS;
 		}
+		if (this.deliveryMode !== "dht") this.session.start();
 		if (this.tracker && !this.tracker.done && this.options.pairingProgress?.role === "joiner") {
 			this.dht?.expect();
 			this.dialEarly();
@@ -18278,6 +18606,7 @@ var GhostLink = class {
 	disconnect() {
 		this.closeRetired();
 		this.dropCrossed();
+		this.dropCrossedProbe();
 		this.dropBlockedDial();
 		this.switcher.stop();
 		this.cancelCandidate();
@@ -19173,9 +19502,30 @@ var GhostLink = class {
 			epoch,
 			rest
 		};
+		if (!this.peerTransports.includes("webrtc/1")) {
+			traceLink(this.myPubKeyZ32, "offer-unanswerable", { transports: rest });
+			this.clearRace();
+			this.raceTimer = setTimeout(() => {
+				this.raceTimer = null;
+				this.endUnanswerableOffer(epoch);
+			}, 0);
+			return;
+		}
 		traceLink(this.myPubKeyZ32, "race-standing", { transports: rest });
 		this.scheduleRace(epoch, made.at);
 	}
+	/** The offer ends (`raceStandingOffer`), and with it going idle what is ranked after WebRTC is dialled (`dialAfterRtc`). */
+	endUnanswerableOffer(epoch) {
+		if (epoch !== this.connectionEpoch || this.channel || this.stopped || !this.offerOut || this.afterRtc?.epoch !== epoch) return;
+		if (this.dialing) {
+			this.raceTimer = setTimeout(() => {
+				this.raceTimer = null;
+				this.endUnanswerableOffer(epoch);
+			}, RACE_RETRY_MS);
+			return;
+		}
+		this.dataLink.close();
+	}
 	/**
 	* Back after an absence, this side answers an offer the contact made while it was away (it dials whatever its key):
 	* the contact looks for that answer at the pace of an offer out a while (every 8 s on the relays), and its attempt may
@@ -19284,6 +19634,18 @@ var GhostLink = class {
 		if (!this.options.params.profile || this.options.packetTransports) return true;
 		return this.transportOffer().some((t) => t === "webrtc/1" ? !this.peerTransports || this.peerTransports.includes(t) : this.canDial(t) && !!this.peerTransports?.includes(t));
 	}
+	/**
+	* Neither side can dial the other until something changes, past a first pairing: what the contact runs is known, and
+	* no transport both run has WebRTC on both sides or an endpoint up on both (this side's, and the one its record
+	* describes). A chat that gave its listener up to another (`yieldEndpoint`), or whose contact did, is so. It dials
+	* again when that changes (a listener taken back, `registerEndpoint`; the record describing one, `learnPeerTransports`),
+	* and reads at its own pace meanwhile: looks every 20 s for a dial with nothing to try, and the contact's fast looks
+	* for an offer that could not come, read its key 2.5x to 4x as often as the background pace, for good (bug hunt,
+	* 2026-10-12). A first pairing keeps both: the records are what it is reading for.
+	*/
+	nothingToDialEitherWay() {
+		return !(!!this.tracker && !this.tracker.done && this.tracker.progress.stage !== "on-dht") && !!this.peerTransports && !this.anythingToDial();
+	}
 	clearRace() {
 		if (this.raceTimer) clearTimeout(this.raceTimer);
 		this.raceTimer = null;
@@ -19346,6 +19708,13 @@ var GhostLink = class {
 		this.attemptEnded();
 		this.rejectWaiters(new GhostlyHttpError("unreachable", "Could not connect to the peer"));
 	}
+	/**
+	* This side does not dial on its own: the contact's app does (the lower key), and none of what makes this side dial
+	* anyway holds (a first pairing's role, a restart, WebRTC set aside). Its own dial, chosen by hand, is not retried.
+	*/
+	awaitsContactDial() {
+		return !(!!this.tracker && !this.tracker.done && this.tracker.progress.stage !== "on-dht" ? this.options.pairingProgress?.role : void 0) && this.myPubKeyZ32 > this.options.params.peerPubKeyZ32 && !this.resuming && !this.dialsPastRtc();
+	}
 	/** A transport of the attempt under way did not connect. */
 	attemptFailed(transport, error) {
 		if (this.isDataLinkOpen) return;
@@ -19368,7 +19737,7 @@ var GhostLink = class {
 			side: attempt.side,
 			failed: attempt.failed,
 			...!attempt.failed.length && reason ? { reason } : {},
-			...attempt.side === "dialled" ? { retryAt: Math.max(Date.now(), this.lastAutoConnectAt + this.dialWait()) } : {}
+			...attempt.side === "dialled" && !this.awaitsContactDial() ? { retryAt: Math.max(Date.now(), this.lastAutoConnectAt + this.dialWait()) } : {}
 		};
 		traceLink(this.myPubKeyZ32, "attempt-ended", {
 			side: attempt.side,
@@ -19407,9 +19776,11 @@ var GhostLink = class {
 			if (this.pairedPending.size >= 128) this.pairedPending.delete(this.pairedPending.keys().next().value);
 			const id = stableId ?? toBase64Url(randomBytes(16));
 			if (!/^[A-Za-z0-9_-]{22}$/.test(id)) return "Invalid message ID";
+			const frame = pairedMessageFrame(id, timestamp, trimmed, preview, reply, forwarded, card);
+			if (frame.length > 61440) return PAIRED_FRAME_TOO_LARGE;
 			this.pairedPending.set(id, timestamp);
 			try {
-				this.channel.send(pairedMessageFrame(id, timestamp, trimmed, preview, reply, forwarded, card));
+				this.channel.send(frame);
 				return null;
 			} catch {
 				this.pairedPending.delete(id);
@@ -19575,15 +19946,14 @@ var GhostLink = class {
 			if (presence.lastPacketAt === this.departed.packet && Date.now() < this.departed.until) return;
 			this.departed = null;
 		}
-		const role = !!this.tracker && !this.tracker.done && this.tracker.progress.stage !== "on-dht" ? this.options.pairingProgress?.role : void 0;
-		if (role === "inviter") {
+		if ((!!this.tracker && !this.tracker.done && this.tracker.progress.stage !== "on-dht" ? this.options.pairingProgress?.role : void 0) === "inviter") {
 			this.peerSeenAt ||= Date.now();
 			if (Date.now() - this.peerSeenAt < 2500 && !this.nothingToAwait()) {
 				this.session.expectPeer();
 				return;
 			}
-		} else if (role !== "joiner" && this.myPubKeyZ32 > this.options.params.peerPubKeyZ32 && !this.resuming && !this.dialsPastRtc()) {
-			if (Date.now() - presenceSeenAt(presence) < 3e4 && presence.lastPacketAt !== this.offerAwaitedFor) {
+		} else if (this.awaitsContactDial()) {
+			if (Date.now() - presenceSeenAt(presence) < 3e4 && presence.lastPacketAt !== this.offerAwaitedFor && !this.nothingToDialEitherWay()) {
 				this.offerAwaitedFor = presence.lastPacketAt;
 				this.session.expectPeer();
 			}
@@ -19661,6 +20031,7 @@ var GhostLink = class {
 		this.retryLook = null;
 		const from = this.lastAutoConnectAt;
 		if (!from || this.stopped || this.leaving || this.streamBlocked || this.keyStopped || !this.options.autoConnect) return;
+		if (this.nothingToDialEitherWay()) return;
 		this.retryLook = setTimeout(() => {
 			this.retryLook = null;
 			if (this.lastAutoConnectAt !== from || this.stopped || this.leaving || this.yielding || this.streamBlocked || this.keyStopped || this.channel || this.dialing || this.dataLink.state !== "idle") return;
@@ -19920,6 +20291,7 @@ var GhostLink = class {
 		if (this.options.callsSupport) offered.push(CALLS_CAPABILITY);
 		if (this.options.servicesSupport) offered.push(SERVICES_CAPABILITY);
 		if (this.options.largeFilesSupport) offered.push(FILES_CAPABILITY);
+		if (this.options.largeFilesSupport && this.options.binaryFilesSupport && this.channel?.binary) offered.push(FILES_BINARY_CAPABILITY);
 		if (this.options.typingSupport) offered.push(TYPING_CAPABILITY);
 		if (this.options.reactionsSupport) offered.push(REACTIONS_CAPABILITY);
 		if (this.options.editSupport) offered.push(EDIT_CAPABILITY);
@@ -19956,6 +20328,10 @@ var GhostLink = class {
 	get supportsLargeFiles() {
 		return this.isDataLinkOpen && this.sessionCapabilities.agreed("files/3");
 	}
+	/** Both sides offer `files/4` beside `files/3` on the open session: a file's bytes go as binary messages. */
+	get supportsBinaryFiles() {
+		return this.supportsLargeFiles && this.sessionCapabilities.agreed("files/4");
+	}
 	/** Both sides offer `typing/1` on the open session: typing can be said and shown. */
 	get supportsTyping() {
 		return this.isDataLinkOpen && this.sessionCapabilities.agreed("typing/1");
@@ -20119,21 +20495,33 @@ var GhostLink = class {
 	}
 	/**
 	* One data frame of an app open on both sides, on the live session only. An error when it did not go: nothing is
-	* kept to send later.
+	* kept to send later. While the channel already holds a quarter of what it may queue (its send budget, or the high
+	* water mark of a WebRTC channel), the frame is refused with `too-fast`, so the chat's messages and pings never wait
+	* behind an app's data on a link slower than it sends (WISP 1200 § In a chat). While a file goes, that quarter sits
+	* above what files may hold (`filesWritable`): files keep the channel at their own line for the whole transfer. While
+	* the file waits for room, the app gets no further than `APP_AHEAD_OF_FILES` ahead of it, so it cannot refill the
+	* channel each time it drains to files' line and keep the file from moving.
 	*/
 	sendAppData(app, data) {
 		if (!this.apps.open.has(app)) return "not-open";
 		if (appDataBytes(data) > 32768) return "too-large";
 		if (!this.channel || !this.isDataLinkOpen) return "offline";
 		if (!this.supportsApps) return "peer-closed";
+		const use = this.filesUse?.channel === this.channel ? this.filesUse : null;
+		const files = use && (use.waiting > 0 || Date.now() - use.at < FILES_IN_USE_MS) ? use : null;
+		if (use && !files) use.appAhead = 0;
+		if (this.channel.bufferedAmount >= (files ? filesCap(this.channel) : 0) + (this.channel.sendBudget ?? LIMITS.sendHighWaterMark) / 4) return "too-fast";
+		if (files && files.waiting > 0 && files.appAhead >= APP_AHEAD_OF_FILES) return "too-fast";
 		const refused = this.apps.canSend(app, data);
 		if (refused) return refused;
+		const frame = JSON.stringify(appDataFrame(app, data));
 		try {
-			this.channel.send(JSON.stringify(appDataFrame(app, data)));
-			return null;
+			this.channel.send(frame);
 		} catch {
 			return "offline";
 		}
+		if (files) files.appAhead = Math.min(files.appAhead + frame.length, APP_AHEAD_OF_FILES + APP_DATA_MAX_BYTES);
+		return null;
 	}
 	/** What the contact had open is gone (`apps/1` is no longer agreed, or this link stopped): each app hears it now. */
 	appsEnded() {
@@ -20176,19 +20564,64 @@ var GhostLink = class {
 		}
 	}
 	/**
+	* A file's bytes to the contact, on the open session: one binary message while both sides agreed `files/4` on it,
+	* the `pf-data` frame with them as base64url text otherwise (WISP 501 § files/4). The form is chosen for each chunk,
+	* so a transfer follows the session it is on. False when files/3 cannot flow now, or the channel has no room.
+	*/
+	sendFileData(id, offset, data) {
+		if (!this.supportsLargeFiles || !this.channel) return false;
+		try {
+			const frame = this.supportsBinaryFiles ? encodeFileData(id, offset, data) : JSON.stringify({
+				t: "pf-data",
+				id,
+				offset,
+				data: toBase64Url(data)
+			});
+			this.channel.send(frame);
+			const use = this.filesUsing(this.channel);
+			use.at = Date.now();
+			use.appAhead = Math.max(0, use.appAhead - (typeof frame === "string" ? frame.length : frame.byteLength));
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Files on a channel: when they last wrote on it, how many wait for room, and how many bytes an app's data has sent
+	* on it beyond theirs since. An app's data gets room above theirs.
+	*/
+	filesUse = null;
+	filesUsing(channel) {
+		if (this.filesUse?.channel !== channel) this.filesUse = {
+			channel,
+			at: 0,
+			waiting: 0,
+			appAhead: 0
+		};
+		return this.filesUse;
+	}
+	/**
 	* Resolves once the open session can take another files/3 data frame; undefined when it can now. A channel with a send budget (native and
 	* iroh ones throw past 120 KiB) gives files a quarter of it, so a ping, a message or any other frame still fits
-	* while a file goes; others keep under the high water mark, as files/2 does.
+	* while a file goes; others keep under the high water mark, as files/2 does. An app's data gets a quarter above that
+	* line meanwhile (`sendAppData`).
 	*/
 	filesWritable() {
 		const channel = this.channel;
 		if (!channel) return;
-		const cap = channel.sendBudget ? channel.sendBudget / 4 : LIMITS.sendHighWaterMark;
+		const cap = filesCap(channel);
 		if (channel.bufferedAmount < cap) return;
+		const use = this.filesUsing(channel);
+		use.waiting++;
 		return (async () => {
-			while (this.channel === channel && channel.bufferedAmount >= cap) {
-				await channel.drained().catch(() => {});
-				if (this.channel === channel && channel.bufferedAmount >= cap) await new Promise((resolve) => setTimeout(resolve, 20));
+			try {
+				while (this.channel === channel && channel.bufferedAmount >= cap) {
+					await channel.drained().catch(() => {});
+					if (this.channel === channel && channel.bufferedAmount >= cap) await new Promise((resolve) => setTimeout(resolve, 20));
+				}
+			} finally {
+				use.waiting--;
+				use.at = Date.now();
 			}
 		})();
 	}
@@ -20486,13 +20919,20 @@ var GhostLink = class {
 		}
 		const held = this.channel;
 		if (held && this.activeBinding && !this.dialedIn.has(held) && Date.now() - this.channelSince < 1e4 && this.myPubKeyZ32 < this.options.params.peerPubKeyZ32) {
-			traceLink(this.myPubKeyZ32, "dial-crossed", {
-				transport: binding.transport,
-				held: true
-			});
-			channel.close();
+			if (this.paired?.state.status !== "ready") {
+				traceLink(this.myPubKeyZ32, "dial-crossed", {
+					transport: binding.transport,
+					held: true
+				});
+				channel.close();
+				return;
+			}
+			this.probeCrossed(held, channel, binding);
 			return;
 		}
+		this.replaceWith(channel, binding);
+	}
+	replaceWith(channel, binding) {
 		traceLink(this.myPubKeyZ32, "replacing", {
 			transport: binding.transport,
 			held: this.paired?.state.transport
@@ -20503,6 +20943,62 @@ var GhostLink = class {
 		});
 	}
 	/**
+	* The contact dialled in while this side's own fresh dial holds the chat (`CROSSED_FRESH_MS`): the dials crossed, or
+	* the contact's app ended since that dial and is back. The held session is pinged; heard from within
+	* `CROSSED_PROBE_MS`, the contact holds this side's dial too and its own closes. Not heard from, the contact's dial
+	* takes over.
+	*/
+	crossedProbe = null;
+	/** Frames heard on the open session, counted from its start: whether the contact answered `probeCrossed`. */
+	framesHeard = 0;
+	probeCrossed(held, channel, binding) {
+		this.dropCrossedProbe();
+		traceLink(this.myPubKeyZ32, "dial-crossed", {
+			transport: binding.transport,
+			held: true,
+			probe: true
+		});
+		const heard = this.framesHeard;
+		try {
+			this.sendPing(held, false);
+		} catch {}
+		const timer = setTimeout(() => {
+			if (this.crossedProbe?.channel !== channel) return;
+			this.crossedProbe = null;
+			if (this.stopped || this.leaving || this.candidate) {
+				channel.close();
+				return;
+			}
+			if (!this.channel) {
+				this.attach(channel, binding);
+				return;
+			}
+			if (this.channel === held && this.framesHeard !== heard) {
+				channel.close();
+				return;
+			}
+			traceLink(this.myPubKeyZ32, "crossed-held-silent", { transport: binding.transport });
+			this.replaceWith(channel, binding);
+		}, CROSSED_PROBE_MS);
+		channel.onClose = () => {
+			if (this.crossedProbe?.channel === channel) {
+				clearTimeout(timer);
+				this.crossedProbe = null;
+			}
+		};
+		this.crossedProbe = {
+			channel,
+			timer
+		};
+	}
+	dropCrossedProbe() {
+		const probe = this.crossedProbe;
+		if (!probe) return;
+		this.crossedProbe = null;
+		clearTimeout(probe.timer);
+		probe.channel.close();
+	}
+	/**
 	* Connections that came in on this side's native endpoints. Their address was in the capability record, which before
 	* the pin anyone holding a copy of the invite could read: a key other than the pinned one on such a connection proves
 	* no more than on the DHT, so it closes that connection and nothing else.
@@ -20697,7 +21193,18 @@ var GhostLink = class {
 					if (this.channel !== channel) return;
 					this.unansweredPings = 0;
 					this.heardFromPeer();
-					if (typeof data !== "string" || data.length > 61440) return;
+					this.framesHeard++;
+					if (typeof data !== "string") {
+						const chunk = this.supportsBinaryFiles ? decodeFileData(data) : null;
+						if (!chunk) return;
+						this.activityAt = Date.now();
+						await this.options.events?.onFilesFrame?.({
+							t: "pf-data",
+							...chunk
+						});
+						return;
+					}
+					if (data.length > 61440) return;
 					let frame;
 					try {
 						frame = JSON.parse(data);
@@ -25454,6 +25961,7 @@ function readFirstPlace(o, epoch) {
 /** One of my own frames, among mine: `e:n`. */
 var ownKey = (f) => `${f.e}:${f.n}`;
 /** What a frame weighs in a log, roughly: its boxes plus the fixed fields around them. */
+var frameKey$1 = (f) => `${f.s}:${f.e}:${f.n}`;
 /** What a kept frame counts for against `GROUP_LIMITS.relayBytes`. */
 var frameBytes = (f) => f.c.length + (f.m?.c.length ?? 0) + (f.r?.c.length ?? 0) + (f.sc?.c.length ?? 0) + (f.fl?.c.length ?? 0) + 400;
 /** Only the fields an edit frame has, as `clean` does for a message. */
@@ -25574,8 +26082,15 @@ var GroupSession = class {
 	pendingMeta;
 	/** While `handle` runs: the frames it took that a hub passes on (`handle`'s result). */
 	passOn = null;
+	/** The frames kept to hand on that the app holds with its messages, oldest first; undefined when the state holds them all. */
+	onRows;
 	/** Set while a save of what received messages changed is due (`persistSoon`). */
 	saveTimer;
+	/**
+	* The frames of members who left that each member was handed (`frameKey`), so an app that does not take them (from
+	* before revision 2026-10-13, and never marks them seen) is not handed them again at every sync. In memory only.
+	*/
+	leaversHanded = /* @__PURE__ */ new Map();
 	/** Syncs answered per member, a few a minute (`GROUP_LIMITS.syncAnswers`). In memory only. */
 	syncsAnswered = /* @__PURE__ */ new Map();
 	/** Catch-up answers still going out, a slice at a time (`handOut`). */
@@ -25588,10 +26103,21 @@ var GroupSession = class {
 	provisional;
 	/** When my chain last moved (a commit made or applied), by `hooks.clock`: frames are said again once it has settled. */
 	chainMovedAt;
-	constructor(state, hooks) {
+	/**
+	* `onRows`: the frames the app holds with the messages it stored (`GroupIncomingMessage.frame`), oldest first. Given
+	* (empty at first), the app is where frames are kept: the saved state carries none of them, and a message received
+	* no longer writes them all again. Absent: they are kept in the state, as before.
+	*/
+	constructor(state, hooks, onRows) {
 		this.hooks = hooks;
 		this.state = state;
 		this.identity = identityFromSeedB64(state.seedB64);
+		if (onRows) {
+			const held = new Set(onRows.map(frameKey$1));
+			if (state.relay?.length) state.relay = state.relay.filter((f) => !held.has(frameKey$1(f)));
+			this.onRows = state.status === "active" ? onRows.filter((f) => this.handsOn(f.s, f.e)) : [];
+			this.trimRelay();
+		}
 		this.answers = new CatchUpAnswers({
 			send: (to, frame) => hooks.send(to, frame),
 			...hooks.handled && { handled: (to) => hooks.handled(to) },
@@ -26003,9 +26529,13 @@ var GroupSession = class {
 		this.hooks.changed();
 		return { secret };
 	}
-	/** Someone out of the roster is not handed on any more, whatever they sent while in it (WISP 902 § Catch-up). */
+	/**
+	* Someone removed is not handed on any more, whatever they sent while in the roster; one who left still is, for the
+	* epochs before its leave (WISP 902 § Catch-up).
+	*/
 	pruneRelay() {
-		if (this.state.relay?.length) this.state.relay = this.state.relay.filter((f) => rosterHas(this.roster, f.s));
+		if (this.state.relay?.length) this.state.relay = this.state.relay.filter((f) => this.handsOn(f.s, f.e));
+		if (this.onRows?.length) this.onRows = this.onRows.filter((f) => this.handsOn(f.s, f.e));
 		if (this.state.relayEdits?.length) this.state.relayEdits = this.state.relayEdits.filter((f) => rosterHas(this.roster, f.s));
 	}
 	/** Another member's edit, kept to hand on: the latest per message; the oldest go once the log is full. False: one as new was kept. */
@@ -26021,10 +26551,21 @@ var GroupSession = class {
 	}
 	/** A frame of another member, kept to hand on; the oldest go once the log is full. */
 	keep(frame) {
-		const log = this.state.relay ??= [];
-		log.push(frame);
-		let bytes = log.reduce((sum, f) => sum + frameBytes(f), 0);
-		while (log.length > GROUP_LIMITS.relay || bytes > GROUP_LIMITS.relayBytes) bytes -= frameBytes(log.shift());
+		if (this.onRows) {
+			const key = frameKey$1(frame);
+			if (this.onRows.some((f) => frameKey$1(f) === key)) return;
+			this.onRows.push(frame);
+		} else (this.state.relay ??= []).push(frame);
+		this.trimRelay();
+	}
+	/** The frames kept to hand on, oldest first: the state's, then the ones the app holds with its messages. */
+	kept() {
+		return this.onRows ? [...this.state.relay ?? [], ...this.onRows] : this.state.relay ?? [];
+	}
+	trimRelay() {
+		const old = this.state.relay ?? [], rows = this.onRows ?? [];
+		let bytes = old.reduce((sum, f) => sum + frameBytes(f), 0) + rows.reduce((sum, f) => sum + frameBytes(f), 0);
+		while (old.length + rows.length > GROUP_LIMITS.relay || bytes > GROUP_LIMITS.relayBytes) bytes -= frameBytes((old.length ? old : rows).shift());
 	}
 	pruneSecrets() {
 		const epochs = Object.keys(this.state.secrets).map(Number).sort((a, b) => a - b);
@@ -26060,6 +26601,7 @@ var GroupSession = class {
 		this.state.secrets = {};
 		this.state.sent = [];
 		this.state.relay = [];
+		if (this.onRows) this.onRows = [];
 		this.state.relayEdits = [];
 		this.state.alone = [];
 		this.waiting = [];
@@ -26548,7 +27090,8 @@ var GroupSession = class {
 	}
 	/**
 	* A message, from its author's edge or handed on by another member. Handed on, it is taken only while both are in
-	* the roster (someone removed is neither heard from nor handed on, #300), and its boxes only with the author's `xs`.
+	* the roster (someone removed is neither heard from nor handed on, #300), or from a member in it when its author left
+	* after it (`handsOn`), and its boxes only with the author's `xs`.
 	*/
 	async receiveMessage(from, raw) {
 		if (!isMessageFrame$1(raw)) return;
@@ -26557,7 +27100,7 @@ var GroupSession = class {
 			return;
 		}
 		const relayed = raw.s !== from;
-		if (relayed && (!rosterHas(this.roster, from) || !rosterHas(this.roster, raw.s))) return;
+		if (relayed && (!rosterHas(this.roster, from) || !this.handsOn(raw.s, raw.e))) return;
 		if (!verify(fromBase64Url(raw.sig), messageSigned$1(raw), publicKeyFromZ32(raw.s))) return;
 		if (raw.e > this.epoch) {
 			this.park(from, raw);
@@ -26595,10 +27138,11 @@ var GroupSession = class {
 			n: first.n
 		};
 		if (firstFrame && rosterHas(this.state.chain[first.e]?.m ?? [], this.myKey) && this.isDuplicate(firstFrame)) {
+			await this.hooks.kept?.(groupMessageId(raw.s, first.e, first.n), clean(raw));
 			this.markSeen(raw);
 			this.keep(clean(raw));
 			this.persistSoon();
-			if (rosterHas(this.roster, raw.s)) this.took(clean(raw));
+			if (this.handsOn(raw.s, raw.e)) this.took(clean(raw));
 			return;
 		}
 		const id = first && !this.provisional.has(own) ? groupMessageId(raw.s, first.e, first.n) : own;
@@ -26635,7 +27179,7 @@ var GroupSession = class {
 		if (firstFrame && rosterHas(this.state.chain[firstFrame.e]?.m ?? [], this.myKey)) this.markSeen(firstFrame);
 		this.keep(clean(raw));
 		this.persistSoon();
-		if (rosterHas(this.roster, raw.s)) this.took(clean(raw));
+		if (this.handsOn(raw.s, raw.e)) this.took(clean(raw));
 	}
 	/**
 	* An edit of a member's own message, from its author's edge or handed on by another member: believed only while its
@@ -26669,7 +27213,7 @@ var GroupSession = class {
 		const k = validMentions(body.m, body.text, rosterAdmin(commit.m) === raw.s && this.admin === raw.s);
 		const sc = body.sc === void 0 ? void 0 : readStatusCard(body.sc);
 		if (!validEditNumber(raw.v) && !sc) return;
-		const copy = (this.state.relay ?? []).find((f) => f.s === raw.s && f.e === raw.e && f.n === raw.n);
+		const copy = this.kept().find((f) => f.s === raw.s && f.e === raw.e && f.n === raw.n);
 		const first = copy && readFirstPlace(copy.o, copy.e);
 		await this.hooks.edit?.({
 			id: first ? groupMessageId(raw.s, first.e, first.n) : groupMessageId(raw.s, raw.e, raw.n),
@@ -26830,6 +27374,16 @@ var GroupSession = class {
 			await this.receiveCommit(from, next);
 		}
 	}
+	/**
+	* Whether a frame of `author` under `epoch` is taken from another member, kept and handed on: while its author is in
+	* the roster, or when it left (its removal marked `left`, and it is not back in) and the frame is from before that.
+	*/
+	handsOn(author, epoch) {
+		if (rosterHas(this.roster, author)) return true;
+		const chain = this.state.chain;
+		for (let e = chain.length - 1; e > 0; e--) if (chain[e].k === "remove" && chain[e].s === author) return !!this.state.leftMarks?.[e] && epoch < e;
+		return false;
+	}
 	/** Keeps the admin's mark on a commit that took out a member who left (`GroupCommitFrame.left`) when it holds; true when new. */
 	takeLeftMark(commit, mark) {
 		if (commit.k !== "remove" || typeof mark !== "string" || mark.length !== 86 || !B64$1.test(mark) || this.state.leftMarks?.[commit.e]) return false;
@@ -26924,7 +27478,15 @@ var GroupSession = class {
 		});
 		const lacks = missingIn(frame, from);
 		const asked = new Set(Array.isArray(frame.ask) ? frame.ask.filter((k) => typeof k === "string" && k !== from && k !== this.myKey && rosterHas(this.roster, k)) : []);
-		const kept = asked.size ? (this.state.relay ?? []).filter((f) => asked.has(f.s) && this.state.chain[f.e] && rosterHas(this.state.chain[f.e].m, from) && lacks(f)) : [];
+		const handed = this.leaversHanded.get(from) ?? /* @__PURE__ */ new Set();
+		const kept = !asked.size && !this.state.leftMarks ? [] : this.kept().filter((f) => {
+			if (!this.state.chain[f.e] || !rosterHas(this.state.chain[f.e].m, from) || !lacks(f)) return false;
+			if (asked.has(f.s)) return true;
+			if (rosterHas(this.roster, f.s) || handed.has(frameKey$1(f)) || !this.handsOn(f.s, f.e)) return false;
+			handed.add(frameKey$1(f));
+			return true;
+		});
+		if (handed.size) this.leaversHanded.set(from, handed);
 		answer.push(...asWritten(this.ownLacked(from, frame), kept));
 		for (const author of asked) {
 			const edits = (this.state.relayEdits ?? []).filter((f) => f.s === author && this.state.chain[f.e] && rosterHas(this.state.chain[f.e].m, from));
@@ -27320,6 +27882,8 @@ var COMMUNITY_LIMITS = {
 	/** Commits in one welcome or chain piece. */
 	chainPiece: 100,
 	pendingLeaves: 64,
+	/** Leaves whose mark (`group-left`) is kept, and the epochs one names. */
+	leftMarks: 64,
 	/**
 	* Syncs of one member answered in `syncWindowMs`: each answer may carry the chain's tail, secrets and the whole
 	* store. A member catching up asks every five seconds at most, and every member syncs every thirty; one asking more
@@ -27436,6 +28000,14 @@ var leaveStatement = (g, s) => utf8Encode(JSON.stringify([
 	g,
 	s
 ]));
+/** What the member who committed a leave (`h`) had heard of the leaver then: `e:h16` → its highest number there. */
+var leftStatement = (g, h, hi) => utf8Encode(JSON.stringify([
+	"ghostly-group/2 left",
+	g,
+	h,
+	Object.entries(hi).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)
+]));
+var LEFT_EPOCH = /^\d{1,15}:[a-f0-9]{16}$/;
 /** The secret of an epoch that adds, re-roles or re-links: from the previous one and the commit. */
 function derivedSecret(previous, untaggedHash) {
 	return hkdf(sha256, previous, utf8Encode(untaggedHash), utf8Encode("ghostly-group/2 derived"), 32);
@@ -27899,13 +28471,58 @@ var CommunitySession = class {
 		return -1;
 	}
 	/**
-	* Someone the chain removed (not one who left) and who is not back in: nothing it signs is heard any more, even for
-	* an epoch it was in. What one who left wrote while in the group is still taken and handed on, for the epochs it was
-	* in (WISP 903 § Leaving and removal): its goodbye reaches the members who were away.
+	* Whether a frame of someone the chain took out is still heard. A member removed is heard no more, even for an epoch
+	* it was in. What one who left wrote while in the group is taken and handed on, its goodbye included, up to what the
+	* member who committed the leave had heard of it then (its `group-left` mark), never past it: the leaver still holds
+	* those epochs' secrets, and anything it signs later is not heard (WISP 903 § Leaving and removal). No mark here
+	* (one not come yet, or a committer's app before it) and nothing of it is heard.
 	*/
-	wasExpelled(key) {
+	heardAfterOut(f) {
+		const i = this.outIndex(f.s);
+		if (i < 0) return true;
+		const commit = this.state.chain[i];
+		if (commit.k !== "leave") return false;
+		const high = this.state.left?.[communityCommitHash(commit)]?.hi[seenKey(f.e, f.h)];
+		return high !== void 0 && f.n <= high;
+	}
+	/** The mark of a leave on my branch, as a frame to hand on (see `heardAfterOut`). */
+	leftFrame(key) {
 		const i = this.outIndex(key);
-		return i >= 0 && this.state.chain[i].k === "remove";
+		if (i < 0 || this.state.chain[i].k !== "leave") return void 0;
+		const h = communityCommitHash(this.state.chain[i]), mark = this.state.left?.[h];
+		return mark && {
+			t: "group-left",
+			v: 2,
+			g: this.id,
+			h,
+			hi: mark.hi,
+			sig: mark.sig
+		};
+	}
+	keepLeft(h, mark) {
+		const left = { ...this.state.left ?? {} };
+		delete left[h];
+		left[h] = mark;
+		const keys = Object.keys(left);
+		for (const old of keys.slice(0, Math.max(0, keys.length - COMMUNITY_LIMITS.leftMarks))) delete left[old];
+		this.state.left = left;
+	}
+	/** A leave's mark, from the member who committed it: kept when it is that member's, for a leave I hold. */
+	receiveLeft(frame) {
+		const { h, hi, sig } = frame;
+		if (typeof h !== "string" || !HASH.test(h) || typeof sig !== "string" || !SIG.test(sig) || !isObject$2(hi)) return false;
+		const entries = Object.entries(hi);
+		if (entries.length > COMMUNITY_LIMITS.leftMarks || entries.some(([k, n]) => !LEFT_EPOCH.test(k) || !Number.isSafeInteger(n) || n < 0)) return false;
+		const commit = this.known.get(h);
+		if (!commit || commit.k !== "leave" || this.state.left?.[h]?.sig === sig) return false;
+		const marks = hi;
+		if (!verify(fromBase64Url(sig), leftStatement(this.id, h, marks), publicKeyFromZ32(commit.by))) return false;
+		this.keepLeft(h, {
+			hi: marks,
+			sig
+		});
+		this.persistSoon();
+		return true;
 	}
 	/**
 	* What someone the chain took out is told when it comes back (WISP 903 § Leaving and removal): the commits from where
@@ -28507,10 +29124,11 @@ var CommunitySession = class {
 					continue;
 				}
 				try {
-					await this.commit("leave", {
+					const { hash } = await this.commit("leave", {
 						s: request.s,
 						ls: request.ls
 					}, now);
+					this.markLeft(hash, request.s);
 					done++;
 				} catch {}
 				this.state.pendingLeaves = this.state.pendingLeaves.filter((r) => r !== request);
@@ -28519,6 +29137,25 @@ var CommunitySession = class {
 			return done;
 		});
 	}
+	/** Signs and says how far I had heard a member whose leave I just committed (`group-left`). */
+	markLeft(h, leaver) {
+		const hi = {};
+		const heard = Object.entries(this.state.seen[leaver] ?? {}).filter(([k]) => LEFT_EPOCH.test(k)).slice(-COMMUNITY_LIMITS.leftMarks);
+		for (const [k, entry] of heard) hi[k] = entry.high;
+		const sig = toBase64Url(sign(leftStatement(this.id, h, hi), this.identity.seed));
+		this.keepLeft(h, {
+			hi,
+			sig
+		});
+		this.hooks.broadcast({
+			t: "group-left",
+			v: 2,
+			g: this.id,
+			h,
+			hi,
+			sig
+		});
+	}
 	out(status, reason) {
 		this.state.status = status;
 		this.state.statusReason = reason;
@@ -28780,8 +29417,13 @@ var CommunitySession = class {
 	messageIdOf(f) {
 		return f.s === this.myKey && this.resealedFrom.get(frameKey(f)) || communityMessageId(f.s, f.e, f.h, f.n);
 	}
-	/** Where I am and what I have, for the member at the other end of an edge that just opened. */
-	syncFrame() {
+	/**
+	* Where I am and what I have, for the member at the other end of an edge that just opened. `to`: that member, now
+	* asked: my answer to its own sync asks nothing more for a while. A second sync went, and its answer took the place of
+	* what was left of the first from its start: a member back after 256 messages was handed 288 (2026-10-14).
+	*/
+	syncFrame(to) {
+		if (to) this.asked.set(to, this.hooks.clock?.() ?? Date.now());
 		const have = {};
 		const recent = new Set(this.state.store.map((f) => seenKey(f.e, f.h)));
 		for (const [sender, byKey] of Object.entries(this.state.seen)) for (const [key, entry] of Object.entries(byKey)) {
@@ -28842,6 +29484,7 @@ var CommunitySession = class {
 					return false;
 				case "group-meta": return this.receiveMeta(from, raw);
 				case "group-leave": return this.receiveLeave(frame);
+				case "group-left": return this.receiveLeft(frame);
 				case "group-entry": {
 					if (frame.to !== this.myKey || !isSealed(frame.s) || frame.x !== this.currentEntryKey()) return false;
 					const seed = openSecret(this.identity.seed, this.myKey, frame.s, entryAad(this.id, this.myKey));
@@ -28870,7 +29513,7 @@ var CommunitySession = class {
 			return false;
 		}
 		if (!verify(fromBase64Url(raw.sig), messageSigned(raw), publicKeyFromZ32(raw.s))) return false;
-		if (this.wasExpelled(raw.s)) return false;
+		if (!this.heardAfterOut(raw)) return false;
 		const found = this.commitByShort(raw.e, raw.h);
 		if (!found) {
 			this.park(from, raw);
@@ -29110,16 +29753,22 @@ var CommunitySession = class {
 		const have = frame.have && typeof frame.have === "object" ? frame.have : {};
 		const handed = /* @__PURE__ */ new Set();
 		const unheard = new Set(this.state.unheard ?? []);
+		const marked = /* @__PURE__ */ new Set();
 		for (const stored of this.state.store) {
 			if (stored.s === from) continue;
 			const high = have[stored.s]?.[seenKey(stored.e, stored.h)];
 			if (Number.isSafeInteger(high) && high >= stored.n) continue;
-			if (this.wasExpelled(stored.s)) continue;
+			if (!this.heardAfterOut(stored)) continue;
 			const found = this.commitByShort(stored.e, stored.h);
 			if (!found) continue;
 			const reads = rosterHas(this.rosterAt(found.hash) ?? [], from), mine = stored.s === this.myKey && unheard.has(frameKey(stored));
 			if (!reads && !(mine && rosterHas(this.roster, from))) continue;
 			if (!this.mainIndex.has(found.hash)) this.handSide(from, found.hash, handed, answer);
+			if (!rosterHas(this.roster, stored.s) && !marked.has(stored.s)) {
+				marked.add(stored.s);
+				const left = this.leftFrame(stored.s);
+				if (left) answer.push(left);
+			}
 			answer.push(stored);
 			if (mine && reads) unheard.delete(frameKey(stored));
 		}
@@ -29781,8 +30430,63 @@ function appDigest(manifestBytes) {
 	return toBase64Url(sha256(manifestBytes));
 }
 var u32 = (b, at) => (b[at] << 24 >>> 0) + (b[at + 1] << 16) + (b[at + 2] << 8) + b[at + 3];
-/** Reads and checks a bundle (the order of the checks is part of the format: see above). */
-function readAppBundle(bytes) {
+/**
+* Lets the thread go for one turn: what waits (input, drawing, timers, port messages, IndexedDB answers) runs, then the
+* caller goes on. A message to itself, queued behind the page's other tasks. Never `scheduler.yield()`: in Chromium its
+* continuation outranks every normal task, so a paced read of 4096 revocations held the page's timers, its apps' broker
+* ports and IndexedDB for the whole 1.8 s. Never `setTimeout(0)` but as the last resort: from the fifth nested timer on
+* the browser waits at least 4 ms (HTML's clamp), which made that read take 60% longer than the work, and a hidden tab
+* runs timers once a second.
+*/
+function yieldThread() {
+	if (typeof MessageChannel === "function") return new Promise((resolve) => {
+		const channel = new MessageChannel();
+		channel.port1.onmessage = () => {
+			channel.port1.close();
+			resolve();
+		};
+		channel.port2.postMessage(null);
+	});
+	return new Promise((resolve) => setTimeout(resolve, 0));
+}
+/**
+* A pause for a loop of short steps: `await pause()` after each step lets the thread go once `sliceMs` of work has
+* run since the last time, and answers at once otherwise.
+*/
+function pacer(sliceMs) {
+	let since = performance.now();
+	return () => {
+		if (performance.now() - since < sliceMs) return void 0;
+		return yieldThread().then(() => {
+			since = performance.now();
+		});
+	};
+}
+/** `sha256Paced` hashes up to this much at once: under a millisecond of the thread. */
+var HASH_AT_ONCE = 65536;
+/** Without `crypto.subtle`, `sha256Paced` hashes this much (a few ms), then lets the thread go. */
+var HASH_SLICE = 262144;
+/** `readAppBundleAsync` hashes files for this long at most before it lets the thread go, however small each file. */
+var HASH_SLICE_MS = 5;
+/**
+* SHA-256 of bytes that may be a whole bundle, for a client whose engine shares its page's thread: `sha256` in
+* JavaScript takes about 12 ms per MiB on a desktop CPU, so 16 MiB in one run is a page that draws nothing and takes no
+* input for 200 ms. With `crypto.subtle` the bytes are hashed off the thread; without it (a page not served over
+* HTTPS), a slice at a time with a pause between slices. The bytes must not change until it answers.
+*/
+async function sha256Paced(bytes) {
+	if (bytes.length <= HASH_AT_ONCE) return sha256(bytes);
+	const subtle = globalThis.crypto?.subtle;
+	const away = subtle ? await subtle.digest("SHA-256", bytes).catch(() => null) : null;
+	if (away) return new Uint8Array(away);
+	const hash = sha256.create();
+	for (let at = 0; at < bytes.length; at += HASH_SLICE) {
+		if (at) await yieldThread();
+		hash.update(bytes.subarray(at, at + HASH_SLICE));
+	}
+	return hash.digest();
+}
+function readAppBundleHead(bytes) {
 	if (bytes.length > APP_BUNDLE_LIMITS.bundleBytes) return {
 		ok: false,
 		reason: "too-large"
@@ -29841,17 +30545,18 @@ function readAppBundle(bytes) {
 	};
 	const signed = verifyAppSignature(APP_PREFIXES.app, manifestBytes, statement.signature, manifest.publisher);
 	if (!signed.ok) return signed;
-	const files = /* @__PURE__ */ new Map();
-	for (const f of manifest.files) {
-		const content = bytes.subarray(at, at + f.size);
-		at += f.size;
-		if (toBase64Url(sha256(content)) !== f.sha256) return {
-			ok: false,
-			reason: "file-hash",
-			detail: f.path
-		};
-		files.set(f.path, content);
-	}
+	return {
+		ok: true,
+		head: {
+			manifest,
+			manifestBytes,
+			signature: statement.signature,
+			filesAt: at
+		}
+	};
+}
+/** The last check, once every file's hash held: the icon. */
+function closeAppBundle({ manifest, manifestBytes, signature }, files) {
 	const icon = files.get(APP_ICON_PATH);
 	if (icon) {
 		const size = imageSize(icon);
@@ -29872,11 +30577,54 @@ function readAppBundle(bytes) {
 			manifest,
 			manifestBytes,
 			digest: appDigest(manifestBytes),
-			signature: statement.signature,
+			signature,
 			files
 		}
 	};
 }
+/** Reads and checks a bundle (the order of the checks is part of the format: see above). */
+function readAppBundle(bytes) {
+	const read = readAppBundleHead(bytes);
+	if (!read.ok) return read;
+	const files = /* @__PURE__ */ new Map();
+	let at = read.head.filesAt;
+	for (const f of read.head.manifest.files) {
+		const content = bytes.subarray(at, at + f.size);
+		at += f.size;
+		if (toBase64Url(sha256(content)) !== f.sha256) return {
+			ok: false,
+			reason: "file-hash",
+			detail: f.path
+		};
+		files.set(f.path, content);
+	}
+	return closeAppBundle(read.head, files);
+}
+/**
+* `readAppBundle` for a client whose engine shares its page's thread: the same checks in the same order, with the same
+* refusals, and each file hashed by `sha256Paced`, one after the other, with the thread let go between files every
+* `HASH_SLICE_MS` (64 files of 64 KiB, each hashed at once, held it for 50 ms). The bytes must not change until it
+* answers.
+*/
+async function readAppBundleAsync(bytes) {
+	const read = readAppBundleHead(bytes);
+	if (!read.ok) return read;
+	const files = /* @__PURE__ */ new Map();
+	const pause = pacer(HASH_SLICE_MS);
+	let at = read.head.filesAt;
+	for (const f of read.head.manifest.files) {
+		const content = bytes.subarray(at, at + f.size);
+		at += f.size;
+		if (toBase64Url(await sha256Paced(content)) !== f.sha256) return {
+			ok: false,
+			reason: "file-hash",
+			detail: f.path
+		};
+		files.set(f.path, content);
+		await pause();
+	}
+	return closeAppBundle(read.head, files);
+}
 /** Puts a bundle's parts together, checking nothing: for builders, and for tests that need a broken bundle. */
 function assembleAppBundle(manifestBytes, statementBytes, files) {
 	const total = MAGIC.length + 8 + manifestBytes.length + statementBytes.length + files.reduce((s, f) => s + f.length, 0);
@@ -30238,6 +30986,6 @@ function appStoreDecision(held, read) {
 	return read.digest === held.digest ? "same" : "equivocation";
 }
 //#endregion
-export { parseCommunityEdit as $, receivedTimestamp as $a, identityFromSeed as $c, DHT_FILE_TOO_LARGE as $i, readGroupHave as $n, HANDOFF_PAKE as $o, vapidKeysMatch as $r, verifyEnrollProof as $s, signDidDhtPacket as $t, encodeCommunityLink as A, reactionEmoji as Aa, signTurnPacket as Ac, DHT_TEXT_CAPABILITY as Ai, resolveLightningDestination as An, webLocalFetch as Ao, FILE_LIMITS as Ar, readHandoffTurnFrame as As, DidError as At, GroupWakeLimiter as B, PR_CHECKS as Ba, normalizeRelayUrl as Bc, identityRevocationValue as Bi, INVITE_TAKEN as Bn, extractParamsFromSdp as Bo, mayPin as Br, ENROLL_DONE as Bs, didWebHost as Bt, openGroupTyping as C, readForwarded as Ca, classifyTurnRead as Cc, normalizeDomain as Ci, normalizePubkyKey as Cn, DHT_POLL_INTERVALS as Co, pickHubs as Cr, newHandoffId as Cs, parseAtprotoDidDocument as Ct, GROUP_READ_NOTE_COMMUNITY as D, ReactionWindow as Da, firstDeviceSetSecret as Dc, txtValue as Di, homeserverWebEndpoint as Dn, GhostlyHttpError as Do, readLobby as Dr, readHandoffHave as Ds, DID_DOCUMENT_MAX_BYTES as Dt, CommunitySession as E, REACTION_LIMITS as Ea, TURN_MAX as Ec, recordsName as Ei, pubkyProofPath as En, presenceSeenAt as Eo, readBeaconHead as Er, readHandoffDone as Es, verifyAtprotoRecordProof as Et, knockIdentity as F, pairedReplyAuthor as Fa, turnStatedVerifier as Fc, IDENTITY_REVOCATION_LABEL as Fi, findEndpoint as Fn, RTC_CONFIG as Fo, TypingSender as Fr, readSetUpdate as Fs, didSignedMessages as Ft, GROUP_REACTED_FRAME as G, cardLine as Ga, withRequestOptions as Gc, lastSharedWithMe as Gi, GROUP_FILE_LIMITS as Gn, LEGACY_SERVICES as Go, WAKE_CALL_INTERVAL_MS as Gr, enrollCancelReason as Gs, signingKeys as Gt, groupWakes as H, RUN_RESULTS as Ha, traceLink as Hc, newIdentityBinding as Hi, pairedMessageFrame as Hn, signalHasVideo as Ho, pinIsNewer as Hr, ENROLL_HELLO as Hs, parseDid as Ht, knockRecords as I, readReply as Ia, turnVerifierMark as Ic, IdentityCheckUnavailable as Ii, isFederationId as In, answersOffer as Io, sanitizeTypingStatus as Ir, setAckFrame as Is, didWebDocumentUrl as It, frameBytes as J, sameButtonText as Ja, createRelayPayload as Jc, validExternalKey as Ji, GROUP_WANT_NO_FRAME as Jn, HANDOFF_CANCEL as Jo, newWakeToken as Jr, enrollGrantFrame as Js, didDhtDocument as Jt, GROUP_READ_NOTE as K, cardUrl as Ka, PacketTooLargeError as Kc, PeerProofs as Ki, GROUP_HAVE_FRAME as Kn, serviceIdFromName as Ko, WakeLimiter as Kr, enrollDigits as Ks, staticDidDocument as Kt, mergeKnocks as L, replySnippet as La, DEFAULT_RELAYS as Lc, IdentityExchange as Li, parseCashuRequestPayload as Ln, buildSdpFromSignal as Lo, typingActivity as Lr, setUpdateFrame as Ls, didWebFile as Lt, decodeGroupEntryLink as M, readReaction as Ma, turnInstance as Mc, dialDescriptors as Mi, ENDPOINT as Mn, decodeControl as Mo, transferStalled as Mr, sealHandoffPiece as Ms, checkDidSignature as Mt, encodeGroupEntryLink as N, validReactionNumber as Na, turnKeys as Nc, IDENTITY_MAX_EVIDENCE as Ni, cashuRequestPayload as Nn, encodeControl as No, TYPING_KINDS as Nr, SET_ACK as Ns, didGhostlyServiceEntry as Nt, communityHasFrame as O, nextReactionNumber as Oa, nextTurnPosition as Oc, wellKnownUrl as Oi, pubkyHomeserverOf as On, formatLocalTarget as Oo, shouldBeHub as Or, readHandoffHello as Os, DID_FILE_MAX_BYTES as Ot, entryParams as P, wireReaction as Pa, turnName as Pc, IDENTITY_MAX_VALIDITY as Pi, fedimintRequestPayload as Pn, CALL_SIGNAL_MAX_AGE_MS as Po, TYPING_REFRESH_MS as Pr, SET_UPDATE as Ps, didJwsAlg as Pt, carryMentions as Q, heardTime as Qa, createIdentity as Qc, irohRelayUrl as Qi, readGroupFileMeta as Qn, HANDOFF_OFFER as Qo, checkPushEndpoint as Qr, readEnrollHello as Qs, resolveDidDht as Qt, readKnocks as R, BUTTON_ID as Ra, RelayTransport as Rc, boundVerifiedIdentity as Ri, parseFedimintRequestPayload as Rn, callRtcConfig as Ro, GROUP_PIN_FRAME as Rr, signTombstone as Rs, didWebFileNames as Rt, groupTypingEpoch as S, forwardedAgain as Sa, TURN_SETTLE_MS as Sc, nip05RootKey as Si, newPubkyProofFolder as Sn, DirectPathWatch as So, newerHead as Sr, handoffVersions as Ss, normalizeAtprotoHandle as St, COMMUNITY_LIMITS as T, GROUP_REACTION_FRAME as Ta, TURN_LAST_SEQUENCE as Tc, recordsFromWellKnown as Ti, pubkyProofFile as Tn, RELAY_POLL_INTERVALS as To, readBeacon as Tr, readHandoffCancel as Ts, AtprotoProofError as Tt, parseGroupWakeFrame as U, STATUS_CARD_LIMITS as Ua, budgetRetryMs as Uc, receivedIdentityStatus as Ui, engineError as Un, emptyLinkRecords as Uo, pinNumberHolds as Ur, ENROLL_PROOF as Us, parseDidDocument as Ut, groupWakeFrame as V, PR_STATES as Va, setLinkTraceSink as Vc, identityStatement as Vi, LIVENESS_PING_MS as Vn, parseCallSignal as Vo, nextPinNumber as Vr, ENROLL_GRANT as Vs, normalizeDid as Vt, GROUP_LIMITS as W, buttonLabelClash as Wa, isDiscoveryBudgetError as Wc, revokesIdentity as Wi, engineText as Wn, HTTP_SERVICE_PROTO as Wo, readPin as Wr, enrollCancelFrame as Ws, parseDidSignaturePaste as Wt, GROUP_EDIT_FRAME as X, arrivalKey as Xa, openRelayPayload as Xc, automaticTransport as Xi, groupFileFallback as Xn, HANDOFF_HAVE as Xo, relayRequest as Xr, enrollProofFrame as Xs, encodeDidDhtDeactivated as Xt, COMMUNITY_EDIT_FRAME as Y, statusCardText as Ya, newerPacket as Yc, TRANSPORTS as Yi, fetchesByItself as Yn, HANDOFF_DONE as Yo, parseWakeFrame as Yr, enrollHelloFrame as Ys, didDhtFromPublicKey as Yt, GROUP_EDIT_TEXT_BYTES as Z, claimedTime as Za, parseRelayPayload as Zc, irohDescriptor as Zi, isGroupMessageId as Zn, HANDOFF_HELLO as Zo, wakeRequest as Zr, readEnrollGrant as Zs, encodeDidDhtPacket as Zt, checkAppManifest as _, EDIT_BUFFER_MS as _a, newDeviceSetSecret as _c, dnsProofName as _i, sparkInvoiceDetails as _n, MEMBER_KEY as _o, freshHubs as _r, handoffOfferFrame as _s, atprotoDidMethod as _t, planAppUpdate as a, readImageMeta as aa, decodeInviteCode as ac, STATUS_CARD_CAPABILITY as ai, bytesEqual as al, SEPOLIA_TEST_USDT_FAUCET as an, checkAppRevokeStatement as ao, SIGNAL_HOLD_MS as ar, handoffAttemptAllowed as as, parseSshPublicKey as at, GROUP_TYPING_FRAME as b, dhtEditId as ba, TURN_PUT_WINDOW_MS as bc, encodeDnsQuery as bi, isPubkyKey as bn, verifyCommitSignature as bo, mergeBeacon as br, handoffRetryAfter as bs, checkAtprotoProofRecord as bt, readAppStore as c, sanitizeFileName as ca, inviteOwnership as cc, HOLD_DATED_BACK_MS as ci, toBase64Url as cl, WALLET_NETWORKS as cn, readAppRevocation as co, readGroupSignal as cr, handoffBusyFrame as cs, sshSignCommand as ct, APP_BUNDLE_LIMITS as d, VOICE_LIMITS as da, HANDOFF_CAPABILITY as dc, HoldRefusedError as di, utf8Encode as dl, formatPaymentAmount as dn, signAppRevocation as do, meshHubs as dr, handoffContextProof as ds, BitcoinAddressError as dt, DHT_MESSAGE_TTL as ea, createDeviceInvite as ec, chatAppId as ei, identityFromSeedB64 as el, ETHEREUM_USDT as en, shownTime as eo, readGroupWant as er, HANDOFF_PIECE_BYTES as es, mentionsMember as et, APP_BUNDLE_MAGIC as f, baseMime as fa, deviceEchoFrame as fc, isHoldUrl as fi, validatePaymentTarget as fn, canonicalJson as fo, pickMeshHubs as fr, handoffDataFrame as fs, decodeAnyBitcoinAddress as ft, assembleAppBundle as g, parseVideoMeta as ga, devicePingFrame as gc, decodeDnsResponse as gi, sparkAddressKind as gn, MAX_GROUP_CHAIN as go, doorHubs as gr, handoffManifestFrames as gs, ATPROTO_PROOF_SCOPE as gt, appViewOf as h, voicePeaksOf as ha, deviceLinkPairing as hc, DOMAIN_FILE_MAX_BYTES as hi, SPARK_PROVIDER as hn, GROUP_MEMBER_CAP as ho, beaconRecords as hr, handoffHelloFrame as hs, ATPROTO_PROOF_COLLECTION as ht, checkAppBeforeRun as i, parseImageMeta as ia, createChatInvite as ic, EDIT_CAPABILITY as ii, sanitizeAvatar as il, SEPOLIA_TEST_USDT as in, appRef as io, SIGNAL_FRESH_MS as ir, filePartName as is, SshSigError as it, KNOCK_TTL_MS as j, reactionIsNewer as ja, signTurnRelease as jc, capsDescriptors as ji, decodeBolt11 as jn, LIMITS as jo, transferEnded as jr, readHandoffVerified as js, checkDidJws as jt, decodeCommunityLink as k, queueReaction as ka, readTurnPacket as kc, CapsExchange as ki, requestLnurlInvoice as kn, parseLocalTarget as ko, ChatFiles as kr, readHandoffPake as ks, DID_JWS_MAX_LENGTH as kt, readAppStoreSteps as l, sanitizeMime as la, DEVICES_CAPABILITY as lc, HOLD_LIMITS as li, toZ32 as ll, assertTokenUnits as ln, readAppRevocations as lo, MESH_HUBS as lr, handoffCancelFrame as ls, verifySshSignature as lt, appDigest as m, parseVoiceMeta as ma, deviceKeyZ32 as mc, readManifest as mi, SPARK_NETWORKS as mn, readCanonicalJson as mo, beaconKeys as mr, handoffEphemeral as ms, ATPROTO_FULL_SCOPE as mt, appStoreDecision as n, DHT_FILE_CAPABILITY as na, readDeviceInvite as nc, APPS_CAPABILITY as ni, verify as nl, ONCHAIN_PROVIDER as nn, APP_STATEMENT_LIMITS as no, CarriedTransport as nr, HANDOFF_TIMINGS as ns, SSHSIG_MAX_ARMOR as nt, APP_STORE_LIMITS as o, formatFileSize as oa, encodeInviteCode as oc, UPGRADE_CAPABILITY as oi, fromBase64Url as ol, TEST_USDT_FAUCET_AMOUNT as on, isAppKey as oo, SIGNAL_REPLY_MS as or, handoffAttemptFailed as os, parseSshSignature as ot, APP_ICON_PATH as p, fileMessageText as pa, deviceEchoNonce as pc, newMailbox as pi, walletNetworkOf as pn, canonicalJsonBytes as po, COMMUNITY_TOPOLOGY as pr, handoffDigest as ps, ATPROTO_DECLARED_SCOPE as pt, GroupSession as q, checkStatusCard as qa, RELAY_PAYLOAD_MAX_BYTES as qc, emptyProofLedger as qi, GROUP_WANT_FRAME as qn, HANDOFF_ACK as qo, deviceWakeRequest as qr, enrollDoneFrame as qs, strictBase64Url as qt, appUpdateDecision as r, dhtFileId as ra, OwnInviteError as rc, BUTTONS_CAPABILITY as ri, MAX_AVATAR_LENGTH as rl, PaymentPreflightError as rn, appFingerprint as ro, GROUP_SIGNAL_FRAME as rr, HANDOFF_VERIFIED as rs, SSHSIG_NAMESPACE as rt, checkAppStoreIndex as s, safeBlobType as sa, inviteLink as sc, HOLD_CAPABILITY as si, randomBytes as sl, USDT_PUBLIC_RPC as sn, isAppRef as so, groupSignalFrame as sr, handoffAttemptSucceeded as ss, sameSshKey as st, appRevocationFor as t, peekDhtMailbox as ta, deviceInviteJoinerParams as tc, isAppVersion as ti, publicKeyFromZ32 as tl, EVM_TEST_CHAINS as tn, APP_PREFIXES as to, readGroupWantNo as tr, HANDOFF_REQUEST as ts, groupName as tt, signAppStore as u, PLAYABLE_AUDIO as ua, ENROLL_CAPABILITY as uc, HoldKeys as ui, utf8Decode as ul, assertWholeSats as un, signAppObject as uo, mayBeHub as ur, handoffContext as us, verifyBitcoinMessage as ut, isAppUrl as v, EDIT_RATE_WINDOW_MS as va, seedSigner as vc, domainTxtRecord as vi, isBitcoinAddress as vn, commitHash as vo, lobbyKeys as vr, handoffPakeFrame as vs, atprotoProofRecord as vt, sealGroupTyping as w, COMMUNITY_REACTION_FRAME as wa, turnPutSummary as wc, recordsFromTxt as wi, pubkyProofCapability as wn, EXPECT_PEER_MS as wo, rankHubs as wr, readHandoffAck as ws, shortAtprotoDid as wt, GroupTypingBoard as x, parseLinkPreview as xa, TURN_RAISE_READ_TIMEOUT_MS as xc, isPublicAddress as xi, isPubkyProofFolder as xn, edgeParams as xo, mergeLobby as xr, handoffStreamKey as xs, isAtprotoDid as xt, readAppBundle as y, RateWindow as ya, webCryptoSigner as yc, domainWellKnownFile as yi, PUBKY_PROOF_MAX_BYTES as yn, rosterHas as yo, lobbyRecords as yr, handoffReleaseFrame as ys, atprotoProofRkey as yt, GROUP_WAKE_FRAME as z, ITEM_STATES as za, currentRelays as zc, emptyIdentityLedger as zi, GhostLink as zn, callSignalHeardAt as zo, PIN_LIMITS as zr, verifySetUpdate as zs, didWebFileUrl as zt };
+export { COMMUNITY_EDIT_FRAME as $, cardUrl as $a, budgetRetryMs as $c, PeerProofs as $i, GROUP_WANT_FRAME as $n, HTTP_SERVICE_PROTO as $o, deviceWakeRequest as $r, enrollCancelFrame as $s, didDhtFromPublicKey as $t, CommunitySession as A, COMMUNITY_REACTION_FRAME as Aa, TURN_PUT_WINDOW_MS as Ac, normalizeDomain as Ai, pubkyProofPath as An, DirectPathWatch as Ao, rankHubs as Ar, handoffStreamKey as As, verifyAtprotoRecordProof as At, knockRecords as B, wireReaction as Ba, signTurnPacket as Bc, IDENTITY_MAX_EVIDENCE as Bi, isFederationId as Bn, LIMITS as Bo, TYPING_REFRESH_MS as Br, readHandoffVerified as Bs, didWebDocumentUrl as Bt, sha256Paced as C, EDIT_BUFFER_MS as Ca, deviceEchoNonce as Cc, decodeDnsResponse as Ci, PUBKY_PROOF_MAX_BYTES as Cn, GROUP_MEMBER_CAP as Co, freshHubs as Cr, handoffEphemeral as Cs, atprotoProofRkey as Ct, openGroupTyping as D, parseLinkPreview as Da, newDeviceSetSecret as Dc, encodeDnsQuery as Di, normalizePubkyKey as Dn, rosterHas as Do, mergeLobby as Dr, handoffPakeFrame as Ds, parseAtprotoDidDocument as Dt, groupTypingEpoch as E, dhtEditId as Ea, devicePingFrame as Ec, domainWellKnownFile as Ei, newPubkyProofFolder as En, commitHash as Eo, mergeBeacon as Er, handoffOfferFrame as Es, normalizeAtprotoHandle as Et, KNOCK_TTL_MS as F, queueReaction as Fa, TURN_LAST_SEQUENCE as Fc, wellKnownUrl as Fi, decodeBolt11 as Fn, presenceSeenAt as Fo, ChatFiles as Fr, readHandoffDone as Fs, checkDidJws as Ft, groupWakeFrame as G, ITEM_STATES as Ga, turnStatedVerifier as Gc, boundVerifiedIdentity as Gi, LIVENESS_PING_MS as Gn, answersOffer as Go, PIN_LIMITS as Gr, setAckFrame as Gs, normalizeDid as Gt, readKnocks as H, readReply as Ha, turnInstance as Hc, IDENTITY_REVOCATION_LABEL as Hi, parseFedimintRequestPayload as Hn, encodeControl as Ho, sanitizeTypingStatus as Hr, SET_ACK as Hs, didWebFileNames as Ht, decodeGroupEntryLink as I, reactionEmoji as Ia, TURN_MAX as Ic, CapsExchange as Ii, ENDPOINT as In, GhostlyHttpError as Io, FILE_LIMITS as Ir, readHandoffHave as Is, checkDidSignature as It, GROUP_LIMITS as J, RUN_RESULTS as Ja, RelayTransport as Jc, identityStatement as Ji, pairedMessageFrame as Jn, callSignalHeardAt as Jo, pinIsNewer as Jr, verifySetUpdate as Js, parseDidSignaturePaste as Jt, groupWakes as K, PR_CHECKS as Ka, turnVerifierMark as Kc, emptyIdentityLedger as Ki, PAIRED_FRAME_TOO_LARGE as Kn, buildSdpFromSignal as Ko, mayPin as Kr, setUpdateFrame as Ks, parseDid as Kt, encodeGroupEntryLink as L, reactionIsNewer as La, firstDeviceSetSecret as Lc, DHT_TEXT_CAPABILITY as Li, cashuRequestPayload as Ln, formatLocalTarget as Lo, transferEnded as Lr, readHandoffHello as Ls, didGhostlyServiceEntry as Lt, communityHasFrame as M, REACTION_LIMITS as Ma, TURN_SETTLE_MS as Mc, recordsFromWellKnown as Mi, pubkyHomeserverOf as Mn, DHT_POLL_INTERVALS as Mo, readBeaconHead as Mr, newHandoffId as Ms, DID_FILE_MAX_BYTES as Mt, decodeCommunityLink as N, ReactionWindow as Na, classifyTurnRead as Nc, recordsName as Ni, requestLnurlInvoice as Nn, EXPECT_PEER_MS as No, readLobby as Nr, readHandoffAck as Ns, DID_JWS_MAX_LENGTH as Nt, sealGroupTyping as O, forwardedAgain as Oa, seedSigner as Oc, isPublicAddress as Oi, pubkyProofCapability as On, verifyCommitSignature as Oo, newerHead as Or, handoffReleaseFrame as Os, shortAtprotoDid as Ot, encodeCommunityLink as P, nextReactionNumber as Pa, turnPutSummary as Pc, txtValue as Pi, resolveLightningDestination as Pn, RELAY_POLL_INTERVALS as Po, shouldBeHub as Pr, readHandoffCancel as Ps, DidError as Pt, frameBytes as Q, cardLine as Qa, traceLink as Qc, lastSharedWithMe as Qi, GROUP_HAVE_FRAME as Qn, emptyLinkRecords as Qo, WakeLimiter as Qr, ENROLL_PROOF as Qs, didDhtDocument as Qt, entryParams as R, readReaction as Ra, nextTurnPosition as Rc, capsDescriptors as Ri, fedimintRequestPayload as Rn, parseLocalTarget as Ro, transferStalled as Rr, readHandoffPake as Rs, didJwsAlg as Rt, readAppBundleAsync as S, parseVideoMeta as Sa, deviceEchoFrame as Sc, DOMAIN_FILE_MAX_BYTES as Si, isBitcoinAddress as Sn, readCanonicalJson as So, doorHubs as Sr, handoffDigest as Ss, atprotoProofRecord as St, GroupTypingBoard as T, RateWindow as Ta, deviceLinkPairing as Tc, domainTxtRecord as Ti, isPubkyProofFolder as Tn, MEMBER_KEY as To, lobbyRecords as Tr, handoffManifestFrames as Ts, isAtprotoDid as Tt, GROUP_WAKE_FRAME as U, replySnippet as Ua, turnKeys as Uc, IdentityCheckUnavailable as Ui, GhostLink as Un, CALL_SIGNAL_MAX_AGE_MS as Uo, typingActivity as Ur, SET_UPDATE as Us, didWebFileUrl as Ut, mergeKnocks as V, pairedReplyAuthor as Va, signTurnRelease as Vc, IDENTITY_MAX_VALIDITY as Vi, parseCashuRequestPayload as Vn, decodeControl as Vo, TypingSender as Vr, sealHandoffPiece as Vs, didWebFile as Vt, GroupWakeLimiter as W, BUTTON_ID as Wa, turnName as Wc, IdentityExchange as Wi, INVITE_TAKEN as Wn, RTC_CONFIG as Wo, GROUP_PIN_FRAME as Wr, readSetUpdate as Ws, didWebHost as Wt, GROUP_READ_NOTE as X, appCardId as Xa, normalizeRelayUrl as Xc, receivedIdentityStatus as Xi, engineText as Xn, parseCallSignal as Xo, readPin as Xr, ENROLL_GRANT as Xs, staticDidDocument as Xt, GROUP_REACTED_FRAME as Y, STATUS_CARD_LIMITS as Ya, currentRelays as Yc, newIdentityBinding as Yi, engineError as Yn, extractParamsFromSdp as Yo, pinNumberHolds as Yr, ENROLL_DONE as Ys, signingKeys as Yt, GroupSession as Z, buttonLabelClash as Za, setLinkTraceSink as Zc, revokesIdentity as Zi, GROUP_FILE_LIMITS as Zn, signalHasVideo as Zo, WAKE_CALL_INTERVAL_MS as Zr, ENROLL_HELLO as Zs, strictBase64Url as Zt, assembleAppBundle as _, VOICE_LIMITS as _a, inviteOwnership as _c, HoldKeys as _i, randomBytes as _l, walletNetworkOf as _n, readAppRevocations as _o, meshHubs as _r, handoffBusyFrame as _s, ATPROTO_DECLARED_SCOPE as _t, planAppUpdate as a, irohRelayUrl as aa, enrollProofFrame as ac, vapidKeysMatch as ai, newerPacket as al, EVM_TEST_CHAINS as an, heardTime as ao, readGroupHave as ar, HANDOFF_HAVE as as, groupName as at, pacer as b, parseVoiceMeta as ba, ENROLL_CAPABILITY as bc, newMailbox as bi, utf8Decode as bl, sparkAddressKind as bn, canonicalJson as bo, beaconKeys as br, handoffContextProof as bs, ATPROTO_PROOF_SCOPE as bt, readAppStore as c, peekDhtMailbox as ca, verifyEnrollProof as cc, isAppVersion as ci, createIdentity as cl, SEPOLIA_TEST_USDT as cn, APP_PREFIXES as co, CarriedTransport as cr, HANDOFF_PAKE as cs, SshSigError as ct, APP_BUNDLE_LIMITS as d, parseImageMeta as da, readDeviceInvite as dc, EDIT_CAPABILITY as di, publicKeyFromZ32 as dl, USDT_PUBLIC_RPC as dn, appRef as do, SIGNAL_HOLD_MS as dr, HANDOFF_TIMINGS as ds, sameSshKey as dt, emptyProofLedger as ea, enrollCancelReason as ec, newWakeToken as ei, isDiscoveryBudgetError as el, encodeDidDhtDeactivated as en, checkStatusCard as eo, GROUP_WANT_NO_FRAME as er, LEGACY_SERVICES as es, GROUP_EDIT_FRAME as et, APP_BUNDLE_MAGIC as f, readImageMeta as fa, OwnInviteError as fc, STATUS_CARD_CAPABILITY as fi, verify as fl, WALLET_NETWORKS as fn, checkAppRevokeStatement as fo, SIGNAL_REPLY_MS as fr, HANDOFF_VERIFIED as fs, sshSignCommand as ft, appViewOf as g, PLAYABLE_AUDIO as ga, inviteLink as gc, HOLD_LIMITS as gi, fromBase64Url as gl, validatePaymentTarget as gn, readAppRevocation as go, mayBeHub as gr, handoffAttemptSucceeded as gs, decodeAnyBitcoinAddress as gt, appDigest as h, sanitizeMime as ha, encodeInviteCode as hc, HOLD_DATED_BACK_MS as hi, bytesEqual as hl, formatPaymentAmount as hn, isAppRef as ho, MESH_HUBS as hr, handoffAttemptFailed as hs, BitcoinAddressError as ht, checkAppBeforeRun as i, irohDescriptor as ia, enrollHelloFrame as ic, checkPushEndpoint as ii, createRelayPayload as il, ETHEREUM_USDT as in, claimedTime as io, readGroupFileMeta as ir, HANDOFF_DONE as is, mentionsMember as it, GROUP_READ_NOTE_COMMUNITY as j, GROUP_REACTION_FRAME as ja, TURN_RAISE_READ_TIMEOUT_MS as jc, recordsFromTxt as ji, homeserverWebEndpoint as jn, AWAITING_PEER_MS as jo, readBeacon as jr, handoffVersions as js, DID_DOCUMENT_MAX_BYTES as jt, COMMUNITY_LIMITS as k, readForwarded as ka, webCryptoSigner as kc, nip05RootKey as ki, pubkyProofFile as kn, edgeParams as ko, pickHubs as kr, handoffRetryAfter as ks, AtprotoProofError as kt, readAppStoreSteps as l, DHT_FILE_CAPABILITY as la, createDeviceInvite as lc, APPS_CAPABILITY as li, identityFromSeed as ll, SEPOLIA_TEST_USDT_FAUCET as ln, APP_STATEMENT_LIMITS as lo, GROUP_SIGNAL_FRAME as lr, HANDOFF_PIECE_BYTES as ls, parseSshPublicKey as lt, APP_PERMISSIONS as m, sanitizeFileName as ma, decodeInviteCode as mc, HOLD_CAPABILITY as mi, sanitizeAvatar as ml, assertWholeSats as mn, isAppKey as mo, readGroupSignal as mr, handoffAttemptAllowed as ms, verifyBitcoinMessage as mt, appStoreDecision as n, TRANSPORTS as na, enrollDoneFrame as nc, relayRequest as ni, PacketTooLargeError as nl, resolveDidDht as nn, statusCardText as no, groupFileFallback as nr, HANDOFF_ACK as ns, carryMentions as nt, APP_STORE_LIMITS as o, DHT_FILE_TOO_LARGE as oa, readEnrollGrant as oc, APP_DATA_MAX_BYTES as oi, openRelayPayload as ol, ONCHAIN_PROVIDER as on, receivedTimestamp as oo, readGroupWant as or, HANDOFF_HELLO as os, SSHSIG_MAX_ARMOR as ot, APP_ICON_PATH as p, formatFileSize as pa, createChatInvite as pc, UPGRADE_CAPABILITY as pi, MAX_AVATAR_LENGTH as pl, assertTokenUnits as pn, isAppHash as po, groupSignalFrame as pr, filePartName as ps, verifySshSignature as pt, parseGroupWakeFrame as q, PR_STATES as qa, DEFAULT_RELAYS as qc, identityRevocationValue as qi, pairedMessageFits as qn, callRtcConfig as qo, nextPinNumber as qr, signTombstone as qs, parseDidDocument as qt, appUpdateDecision as r, automaticTransport as ra, enrollGrantFrame as rc, wakeRequest as ri, RELAY_PAYLOAD_MAX_BYTES as rl, signDidDhtPacket as rn, arrivalKey as ro, isGroupMessageId as rr, HANDOFF_CANCEL as rs, parseCommunityEdit as rt, checkAppStoreIndex as s, DHT_MESSAGE_TTL as sa, readEnrollHello as sc, chatAppId as si, parseRelayPayload as sl, PaymentPreflightError as sn, shownTime as so, readGroupWantNo as sr, HANDOFF_OFFER as ss, SSHSIG_NAMESPACE as st, appRevocationFor as t, validExternalKey as ta, enrollDigits as tc, parseWakeFrame as ti, withRequestOptions as tl, encodeDidDhtPacket as tn, sameButtonText as to, fetchesByItself as tr, serviceIdFromName as ts, GROUP_EDIT_TEXT_BYTES as tt, signAppStore as u, dhtFileId as ua, deviceInviteJoinerParams as uc, BUTTONS_CAPABILITY as ui, identityFromSeedB64 as ul, TEST_USDT_FAUCET_AMOUNT as un, appFingerprint as uo, SIGNAL_FRESH_MS as ur, HANDOFF_REQUEST as us, parseSshSignature as ut, checkAppManifest as v, baseMime as va, ownInviteRefusal as vc, HoldRefusedError as vi, toBase64Url as vl, SPARK_NETWORKS as vn, signAppObject as vo, pickMeshHubs as vr, handoffCancelFrame as vs, ATPROTO_FULL_SCOPE as vt, GROUP_TYPING_FRAME as w, EDIT_RATE_WINDOW_MS as wa, deviceKeyZ32 as wc, dnsProofName as wi, isPubkyKey as wn, MAX_GROUP_CHAIN as wo, lobbyKeys as wr, handoffHelloFrame as ws, checkAtprotoProofRecord as wt, readAppBundle as x, voicePeaksOf as xa, HANDOFF_CAPABILITY as xc, readManifest as xi, utf8Encode as xl, sparkInvoiceDetails as xn, canonicalJsonBytes as xo, beaconRecords as xr, handoffDataFrame as xs, atprotoDidMethod as xt, isAppUrl as y, fileMessageText as ya, DEVICES_CAPABILITY as yc, isHoldUrl as yi, toZ32 as yl, SPARK_PROVIDER as yn, signAppRevocation as yo, COMMUNITY_TOPOLOGY as yr, handoffContext as ys, ATPROTO_PROOF_COLLECTION as yt, knockIdentity as z, validReactionNumber as za, readTurnPacket as zc, dialDescriptors as zi, findEndpoint as zn, webLocalFetch as zo, TYPING_KINDS as zr, readHandoffTurnFrame as zs, didSignedMessages as zt };
 
-//# sourceMappingURL=src-CbLkHfz8.js.map
+//# sourceMappingURL=src-DDzSERyc.js.map