@ghostlytools/cli 1.2.3 → 1.2.4

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

@@ -584,6 +584,7 @@ function withRequestOptions(transport, extra) {
 	if (transport.subscribe) wrapped.subscribe = (listener) => transport.subscribe(listener);
 	if (transport.networkChanged) wrapped.networkChanged = () => transport.networkChanged();
 	if (transport.readAnsweredAt) wrapped.readAnsweredAt = (pubKeyZ32) => transport.readAnsweredAt(pubKeyZ32);
+	if (transport.readHeldBackFor) wrapped.readHeldBackFor = (pubKeyZ32) => transport.readHeldBackFor(pubKeyZ32);
 	if (transport.onServerTime) wrapped.onServerTime = (listener) => transport.onServerTime(listener);
 	if (transport.configure) wrapped.configure = (options) => transport.configure(options);
 	if (transport.turnRead) wrapped.turnRead = (pubKeyZ32, options) => transport.turnRead(pubKeyZ32, options);
@@ -798,6 +799,11 @@ var isGroupSignal = (who) => who.group && !who.background && (who.signal || isWa
 var watchLane = (who) => `${+who.urgent}${+who.background}`;
 /** A group's read that is not a background one: an edge's, a private group's knock poll (`GROUP_RATION_WINDOW_MS`). */
 var isGroupRead = (who) => who.group && !who.write && !who.background;
+/**
+* A read that takes its turn per key with the others (`READ_TURN_MS`): a background one, and a 1:1 chat's at any pace.
+* Not a community door's bell.
+*/
+var isTurnRead = (who) => !who.write && !who.door && (who.background || !who.group);
 /** A write that goes first once the budget frees a request (see `WRITE_FIRST_MS`): a chat's or a group's, never a background one. */
 var firstWriter = (who) => !who.write || who.background ? null : who.group ? "group" : "chat";
 /**
@@ -871,6 +877,29 @@ var WATCH_SHARE = 1 / 3;
 * waits, the others wait too (`WATCH_SHARE`, `GROUP_RATION_WINDOW_MS`). One that stops asking loses it.
 */
 var WATCH_TURN_MS = 5e3;
+/**
+* Background reads, and a 1:1 chat's at any pace, take turns per key the same way: while a key read longer ago asked
+* within this long and was not read since, a read of another key waits (a chat's, at a pace that is not the background
+* one, only for another chat's key). A saved chat that is not live reads its contact every 30 s in the
+* background, and one the budget refused read again only at its next poll. A request frees 60 s after the one that took
+* it, which is the poll after next of the chat that took it: the same chats took every request that freed. A daemon with
+* 30 chats and 5 groups, back after a restart while its groups signaled, read some contacts once in 10 min, and those
+* chats stayed down although both sides were online and offering (CLI bug hunt, 2026-10-12). A link's background read
+* the budget refused reads again when it frees a request (`LinkSession`), so the key whose turn it is is there to take it.
+* A chat not live after a restart looks fast while its offer is out, and those reads took no turn: the budget answered
+* them from the packet read before, every 2 to 8 s for 10 minutes, while the chats that were live already, the groups'
+* edges and the writes took every request that freed. A quarter of a daemon's 30 chats read their contact once in 10
+* minutes, their contacts online and offering, and showed them offline at 6 minutes (CLI bug hunt, 2026-10-13).
+*/
+var READ_TURN_MS = 5e3;
+/**
+* A 1:1 chat's read the budget held back this long without a break is starved: it goes before the writes that wait
+* (`WRITE_FIRST_MS`) and past the background share, within the minute, the key held back longest first. A daemon back
+* after a restart spends its whole minute on writes (each chat's and edge's offer, its packets after the attempt), which
+* go first, and requests free in bursts as the minute's first requests age out: every burst went to the writes that
+* waited, and the reads of the chats that were not in an attempt never had their turn (CLI restart lab, 2026-10-13).
+*/
+var READ_STARVED_MS = 6e4;
 /** How long a read that let an older one go first waits before it asks again. */
 var TURN_WAIT_MS = 1e3;
 /**
@@ -990,6 +1019,8 @@ var RelayTransport = class {
 	* it is under the watch share (`WATCH_SHARE`) and while the groups' reads are rationed (`GROUP_RATION_WINDOW_MS`).
 	*/
 	readTurns = /* @__PURE__ */ new Map();
+	/** Per key read in turn (`isTurnRead`), when a read of it last went out and when it last asked (`READ_TURN_MS`). */
+	keyTurns = /* @__PURE__ */ new Map();
 	/** Groups' reads (not background ones) on each relay in the last `GROUP_RATION_WINDOW_MS`. */
 	spentGroupReads = /* @__PURE__ */ new Map();
 	/** When a group's read last found each relay's minute full: its reads there are rationed for `GROUP_RATION_MS`. */
@@ -1009,6 +1040,11 @@ var RelayTransport = class {
 	/** Per relay and key, the newest packet that relay held back for its budget while another relay took it (`catchUpLater`). */
 	catchUp = /* @__PURE__ */ new Map();
 	catchUpTimer = null;
+	/**
+	* Per key whose reads the budget held back since its last read went out: when a request frees for it
+	* (`readHeldBackFor`), how many times in a row, and since when (`READ_STARVED_MS`).
+	*/
+	heldBack = /* @__PURE__ */ new Map();
 	/** When the relays last answered a read of each key, for `FRESH_READ_MS`. */
 	readAt = /* @__PURE__ */ new Map();
 	freshReadMs;
@@ -1398,8 +1434,14 @@ var RelayTransport = class {
 		}
 		const resting = this.relays.every((r) => this.isCoolingDown(r, "GET") || this.breaker.blockedFor(r) > 0 || this.heldFor(r, who, Date.now(), pubKeyZ32) > 0);
 		const known = down ? this.newest.get(pubKeyZ32) : newerPacket(this.newest.get(pubKeyZ32), this.written.get(pubKeyZ32));
-		if (resting && known) return known;
-		if (!down && budgetWait < Infinity) throw new DiscoveryBudgetError(budgetWait);
+		if (resting && known) {
+			if (!down && budgetWait < Infinity) this.heldBackUntil(pubKeyZ32, Date.now() + budgetWait);
+			return known;
+		}
+		if (!down && budgetWait < Infinity) {
+			this.heldBackUntil(pubKeyZ32, Date.now() + budgetWait);
+			throw new DiscoveryBudgetError(budgetWait);
+		}
 		throw new Error("No Pkarr relay reachable");
 	}
 	/** The order a key's read asks the relays in: in turn per key (see `resolve`), relays found slow lately last. */
@@ -1466,9 +1508,25 @@ var RelayTransport = class {
 	readAnsweredAt(pubKeyZ32) {
 		return this.readAt.get(pubKeyZ32);
 	}
+	readHeldBackFor(pubKeyZ32) {
+		const held = this.heldBack.get(pubKeyZ32);
+		const left = held === void 0 ? 0 : held.until - Date.now();
+		return left > 0 ? left : void 0;
+	}
+	heldBackUntil(pubKeyZ32, until) {
+		const held = this.heldBack.get(pubKeyZ32), times = (held?.times ?? 0) + 1;
+		this.heldBack.delete(pubKeyZ32);
+		this.heldBack.set(pubKeyZ32, {
+			until,
+			times,
+			since: held?.since ?? Date.now()
+		});
+		if (this.heldBack.size > READ_TURNS_KEPT) this.heldBack.delete(this.heldBack.keys().next().value);
+	}
 	/** The relays answered a read of this key now; answers older than `FRESH_READ_MS` are dropped as the list grows. */
 	answeredRead(pubKeyZ32) {
 		const now = Date.now();
+		this.heldBack.delete(pubKeyZ32);
 		this.readAt.delete(pubKeyZ32);
 		this.readAt.set(pubKeyZ32, now);
 		if (this.readAt.size > 64) for (const [key, at] of this.readAt) {
@@ -1584,6 +1642,7 @@ var RelayTransport = class {
 			if (isChat(who)) this.chatNeed(key).urgentAt = now;
 		}
 		if (isGroupRead(who)) this.readAsked(key, who, now);
+		if (isTurnRead(who)) this.turnAsked(key, who, now);
 		if (this.heldFor(relay, who, now, key) > 0) {
 			if (isGroupRead(who) && (this.spent.get(relay)?.length ?? 0) >= this.limitOf(relay)) this.groupsFullAt.set(relay, now);
 			if (isChat(who)) this.chatNeed(key).refused.set(relay, now);
@@ -1607,6 +1666,12 @@ var RelayTransport = class {
 				lane: watchLane(who)
 			});
 		}
+		if (isTurnRead(who)) this.keyTurns.set(key, {
+			servedAt: now,
+			askedAt: now,
+			waiting: false,
+			who
+		});
 		return true;
 	}
 	/**
@@ -1618,7 +1683,7 @@ var RelayTransport = class {
 	* signaling goes over the limit by its allowance (`SIGNALING_ALLOWANCE_SHARE`), and so do a few of its reads of a
 	* contact that just went away (`DEPARTED_READS`).
 	*/
-	heldFor(relay, who, now = Date.now(), key) {
+	heldFor(relay, who, now = Date.now(), key, turns = true) {
 		const recent = (this.spent.get(relay) ?? []).filter((at) => now - at < 6e4);
 		const recentBackground = (this.spentBackground.get(relay) ?? []).filter((at) => now - at < 6e4);
 		this.spent.set(relay, recent);
@@ -1628,10 +1693,11 @@ var RelayTransport = class {
 		const departed = isDepartedRead(who) && key !== void 0 && recent.length >= limit && this.departedReads(key, now) < 6;
 		const share = isChatSignal(who) || departed ? SIGNALING_ALLOWANCE_SHARE : isGroupSignal(who) ? GROUP_SIGNALING_ALLOWANCE_SHARE : 0;
 		let wait = over(recent, limit + (share ? Math.max(0, Math.floor(limit * share) - (who.write ? 0 : 1)) : 0));
+		const starved = key !== void 0 && this.starved(key, who, now);
 		const groupOver = (this.spentGroupOver.get(relay) ?? []).filter((at) => now - at < GROUP_OVER_PACE_MS);
 		this.spentGroupOver.set(relay, groupOver);
 		if (isGroupSignal(who) && !who.write && recent.length >= limit && groupOver.length > 0) wait = Math.max(wait, groupOver[groupOver.length - 1] + GROUP_OVER_PACE_MS - now);
-		if (who.background) {
+		if (who.background && !starved) {
 			wait = Math.max(wait, over(recentBackground, this.backgroundPerMinute));
 			const signaling = this.urgentAt + SIGNALING_WINDOW_MS - now;
 			if (signaling > 0 && !who.door) wait = Math.max(wait, Math.min(signaling, over(recentBackground, this.backgroundWhileSignaling)));
@@ -1666,8 +1732,9 @@ var RelayTransport = class {
 			const at = this.writeWaiting.get(`${lane} ${relay}`);
 			return at !== void 0 && now - at < 5e3 ? at + WRITE_FIRST_MS - now : 0;
 		};
-		if (writer !== "chat" && !departed) wait = Math.max(wait, waiting("chat"));
-		if (writer === null && who.group && !pastLimit || who.background) wait = Math.max(wait, waiting("group"));
+		if (writer !== "chat" && !departed && !starved) wait = Math.max(wait, waiting("chat"));
+		if ((writer === null && who.group && !pastLimit || who.background) && !starved) wait = Math.max(wait, waiting("group"));
+		if (turns && wait <= 0 && isTurnRead(who) && this.turnAhead(relay, key, who, now)) wait = TURN_WAIT_MS;
 		return Math.max(wait, 0);
 	}
 	/** A group's read of `key` asks: it waits for its turn from now on, unless it is taken (`readsAhead`). */
@@ -1697,6 +1764,39 @@ var RelayTransport = class {
 		}
 		return ahead;
 	}
+	/** A read of `key` that takes turns asks: it waits for its turn from now on, unless it is taken (`turnAhead`). */
+	turnAsked(key, who, now) {
+		for (const [other, turn] of this.keyTurns) if (now - Math.max(turn.askedAt, turn.servedAt) >= 6e4) this.keyTurns.delete(other);
+		this.keyTurns.set(key, {
+			servedAt: this.keyTurns.get(key)?.servedAt ?? -Infinity,
+			askedAt: now,
+			waiting: true,
+			who
+		});
+	}
+	/**
+	* Whether a key read in turn longer ago than `key`, still asking, would take this relay's next request: one read in the
+	* background for a background read, and a chat's that is starved (`READ_STARVED_MS`) for any. One asks again after
+	* the budget held it back (a link's poll does, a one-off look does not), and keeps asking within `READ_TURN_MS` of its
+	* last ask, or of when it was told the budget frees a request for it (`readHeldBackFor`).
+	* One the budget holds back on its own account (a group's read, for the chats' reserve) keeps no turn: a group key
+	* waiting for the chats held every chat's read back (CLI lab, 2026-10-13).
+	*/
+	turnAhead(relay, key, who, now) {
+		const mine = key === void 0 ? -Infinity : this.keyTurns.get(key)?.servedAt ?? -Infinity;
+		for (const [other, turn] of this.keyTurns) {
+			const held = this.heldBack.get(other);
+			if (other === key || !turn.waiting || turn.servedAt >= mine || !held || held.times < 2) continue;
+			if (!(who.background && turn.who.background) && !this.starved(other, turn.who, now)) continue;
+			if (now - Math.max(turn.askedAt, held.until) < READ_TURN_MS && this.heldFor(relay, turn.who, now, other, false) === 0) return true;
+		}
+		return false;
+	}
+	/** A 1:1 chat's read of `key` the budget has held back for `READ_STARVED_MS` without a break. */
+	starved(key, who, now) {
+		const since = this.heldBack.get(key)?.since;
+		return !who.group && !who.write && !who.door && since !== void 0 && now - since >= READ_STARVED_MS;
+	}
 	/** This contact's departed reads past the limit in the last minute (`DEPARTED_READS`). */
 	departedReads(key, now) {
 		const reads = (this.departedOver.get(key) ?? []).filter((at) => now - at < 6e4);
@@ -6096,13 +6196,15 @@ var LinkSession = class {
 			nextInMs: 0
 		});
 		const started = Date.now();
+		let heldBackMs;
 		try {
 			const pace = this.pace();
 			const signal = pace === "fast" && this.fastStepsAfter > 0 && this.rtcSignalOut !== null;
 			const watch = !signal && this.watching();
 			const departed = !signal && Date.now() < this.departedUntil;
+			const background = pace === "background" || pace === "connected";
 			const packet = await this.transport.resolve(this.peerPubKeyZ32, {
-				background: pace === "background" || pace === "connected",
+				background,
 				urgent: pace === "fast",
 				...signal && { signal },
 				...watch && { watch },
@@ -6117,6 +6219,7 @@ var LinkSession = class {
 			const read = answered !== void 0 && answered >= started;
 			if (read) this.lastReadAt = started;
 			this.readMissed = !!this.transport.readAnsweredAt && !read;
+			if (this.readMissed) heldBackMs = this.transport.readHeldBackFor?.(this.peerPubKeyZ32);
 			let receivedNew = false;
 			const batch = packet ? parseLinkRecords(packet, this.encKey) : null;
 			if (batch && isEmptyLinkPacket(batch)) {
@@ -6205,7 +6308,8 @@ var LinkSession = class {
 					ms: Date.now() - started,
 					error: String(error)
 				});
-				if (!isDiscoveryBudgetError(error)) {
+				if (isDiscoveryBudgetError(error)) heldBackMs = error.retryInMs;
+				else {
 					this.discoveryResult("read", error);
 					this.events.onStatus?.("error");
 				}
@@ -6223,7 +6327,7 @@ var LinkSession = class {
 				this.poll();
 			} else if (this.running && !this.pollTimer) {
 				const interval = this.nextInterval();
-				const wait = Math.max(MIN_POLL_GAP_MS, interval - (Date.now() - started));
+				const wait = heldBackMs !== void 0 ? Math.min(interval, Math.max(BUDGET_RETRY_MIN_MS, heldBackMs)) : Math.max(MIN_POLL_GAP_MS, interval - (Date.now() - started));
 				this.events.onPoll?.({
 					polling: false,
 					nextInMs: wait
@@ -9177,6 +9281,13 @@ var DHT_EXPIRY_SKEW_MS = PKARR_FUTURE_SKEW_MS;
 */
 var DHT_ISSUED_BACK_MS = 12e4;
 var MAX_ATTEMPTS = 8;
+/**
+* Envelope sequences are set aside this many at a time (`DhtDeliveryState.sequence` is the highest set aside): a
+* keep-alive, every four minutes per chat, and one the relays' budget turns away, every 30 s on a profile idling at
+* it, then cost no disk write of their own. A reader only needs the sequence to grow, so those a restart skips cost
+* nothing; one the budget turned away is not used again, as it may have gone out on the DHT (the CLI puts there too).
+*/
+var SEQUENCE_BLOCK = 64;
 /** The wait before publication attempt `attempts + 1` of a text, or of a receipt the contact still asks for. */
 var backoff = (attempts) => Math.min(6e4, 4e3 * 2 ** attempts);
 /** The contact's mailbox is read this often while either side is DHT-only, and otherwise… */
@@ -9230,6 +9341,10 @@ var emptyDhtDeliveryState = () => ({
 var DhtDelivery = class DhtDelivery {
 	options;
 	state;
+	/** The state as last saved: a save that would write the same row again is skipped. */
+	saved;
+	/** The sequence of the last envelope signed here; the state's is the highest set aside (`SEQUENCE_BLOCK`). */
+	sequence;
 	mode;
 	running = false;
 	ticking = false;
@@ -9284,6 +9399,8 @@ var DhtDelivery = class DhtDelivery {
 		const { peerRejected: _peerRejected, ...state } = structuredClone(options.state ?? emptyDhtDeliveryState());
 		this.state = state;
 		this.mode = options.mode;
+		this.sequence = state.sequence;
+		if (options.state) this.saved = JSON.stringify(state);
 		this.unsealedOut = state.sequence > 0 && !options.credentials.peerKey;
 		this.from = identityFromSeedB64(options.params.seedB64).pubKeyZ32;
 		this.to = options.params.peerPubKeyZ32;
@@ -9372,7 +9489,11 @@ var DhtDelivery = class DhtDelivery {
 		return operation;
 	}
 	async persist(next) {
-		await this.options.save(structuredClone(next));
+		const json = JSON.stringify(next);
+		if (json !== this.saved) {
+			await this.options.save(structuredClone(next));
+			this.saved = json;
+		}
 		this.state = next;
 	}
 	sealedKey(peer) {
@@ -9547,7 +9668,7 @@ var DhtDelivery = class DhtDelivery {
 	}
 	packetError(message, expires, reply, edit) {
 		try {
-			this.records(this.body(this.state.sequence + 1, Date.now(), expires, message, this.state.receipt?.id ?? "abcdefghijklmnopqrstuv", reply, [], edit), this.options.credentials.peerKey ?? this.participation.pubKeyZ32);
+			this.records(this.body(this.sequence + 1, Date.now(), expires, message, this.state.receipt?.id ?? "abcdefghijklmnopqrstuv", reply, [], edit), this.options.credentials.peerKey ?? this.participation.pubKeyZ32);
 			return null;
 		} catch (error) {
 			return error instanceof Error ? error.message : String(error);
@@ -9555,7 +9676,7 @@ var DhtDelivery = class DhtDelivery {
 	}
 	/** Whether a text with its hop count fits the packet and what a reader reads (`MAX_ENVELOPE_PLAINTEXT`). */
 	roomForHops(message, expires, reply, forwarded) {
-		const body = this.body(this.state.sequence + 1, Date.now(), expires, message, this.state.receipt?.id ?? "abcdefghijklmnopqrstuv", reply, [], void 0, forwarded);
+		const body = this.body(this.sequence + 1, Date.now(), expires, message, this.state.receipt?.id ?? "abcdefghijklmnopqrstuv", reply, [], void 0, forwarded);
 		try {
 			this.records(body, this.options.credentials.peerKey ?? this.participation.pubKeyZ32);
 		} catch {
@@ -9634,7 +9755,7 @@ var DhtDelivery = class DhtDelivery {
 		], expires = now + DHT_MESSAGE_TTL;
 		const hops = readForwarded(forwarded);
 		const fits = (element, withReply, withHops) => {
-			const body = this.body(this.state.sequence + 1, now, expires, message, this.state.receipt?.id ?? "abcdefghijklmnopqrstuv", withReply ? reply : void 0, [], void 0, withHops ? hops : void 0, element);
+			const body = this.body(this.sequence + 1, now, expires, message, this.state.receipt?.id ?? "abcdefghijklmnopqrstuv", withReply ? reply : void 0, [], void 0, withHops ? hops : void 0, element);
 			try {
 				this.records(body, this.options.credentials.peerKey ?? this.participation.pubKeyZ32);
 			} catch {
@@ -9823,13 +9944,14 @@ var DhtDelivery = class DhtDelivery {
 		if (keepAlive && this.controlDue > now) return;
 		const expires = pending?.expires ?? now - 12e4 + CONTROL_TTL;
 		const issued = Math.min(now, Math.max(now - DHT_ISSUED_BACK_MS, expires - (pending ? DHT_MESSAGE_TTL : CONTROL_TTL), (pending?.message[1] ?? 0) - 3e4));
-		const { body, records, reactions } = this.fitted(this.state.sequence + 1, issued, expires, pending?.message ?? null, receipt?.id ?? null, pending?.reply, pending?.edit, pending?.forwarded, pending?.file);
+		const { body, records, reactions } = this.fitted(this.sequence + 1, issued, expires, pending?.message ?? null, receipt?.id ?? null, pending?.reply, pending?.edit, pending?.forwarded, pending?.file);
 		const reactionsWereDue = this.reactionsDue;
 		this.reactionsDue = !reactions && !!this.options.reactions?.().length;
 		const identity = !reseal && this.state.peerPinned && this.state.peerPinned !== "can" && this.pinned()?.identity || this.identity;
+		const sequence = body[1];
 		await this.persist({
 			...this.state,
-			sequence: body[1],
+			sequence: sequence > this.state.sequence ? sequence + SEQUENCE_BLOCK - 1 : this.state.sequence,
 			pending: pending ? {
 				...pending,
 				attempts: pending.attempts + 1,
@@ -9841,6 +9963,7 @@ var DhtDelivery = class DhtDelivery {
 				next: now + backoff(receipt.attempts)
 			} : this.state.receipt
 		});
+		this.sequence = sequence;
 		const before = {
 			lastPublish: this.lastPublish,
 			controlDue: this.controlDue
@@ -15619,7 +15742,7 @@ var ChatFiles = class {
 				}
 				return;
 			case "pf-done":
-				if (record.state !== "verifying") return;
+				if (record.state !== "verifying" && record.confirmed !== record.file.size) return;
 				record.confirmed = record.file.size;
 				this.end(outgoing, "done");
 				return;
@@ -16846,6 +16969,7 @@ var ENGINE_ERRORS = {
 	notEnoughSats: "Not enough sats in your wallet",
 	noSharedMint: "You share no mint with this contact",
 	ecashAlreadySpent: "This ecash was already spent somewhere else",
+	ecashBeingReceived: "This ecash is already being received",
 	ecashOtherUnit: "This ecash is in {unit}: only sat ecash can be redeemed here",
 	reviewedEcashSpent: "The ecash for this payment was already spent somewhere else. Nothing was sent, and your balance now shows what the mint still holds.",
 	reviewedSatsGone: "The sats this payment was reviewed with went to another payment. Nothing was sent: review it again.",
@@ -16954,8 +17078,6 @@ 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;
-/** Two dials crossing: how long the lower key's side waits for its own to connect before it takes the contact's. */
-var CROSSED_WAIT_MS = 3e3;
 /** 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",
@@ -17296,10 +17418,15 @@ var GhostLink = class {
 	* was the app's in the background, not a restart (`resumeAfterAbsence`).
 	*/
 	offered;
+	/**
+	* The WebRTC offer this side's dial made last, fallback allowed or not: one made before the contact's record was read
+	* races once it is (`raceStandingOffer`).
+	*/
+	offerMade;
 	/** The attempt (its epoch) whose direct transports were knocked on as its offer went out (`knockEarly`), and whether that is under way. */
 	knockedEarly = -1;
 	knockingEarly = false;
-	/** When that offer's answer was applied (`RACE_ANSWERED_MS`); 0 while the data link is not connecting on it. */
+	/** When this side's offer's answer was applied (`RACE_ANSWERED_MS`); 0 while the data link is not connecting on it. */
 	answeredAt = 0;
 	/** This side's offer is out unanswered, or answered and not connected yet: what is ranked after WebRTC may race it. */
 	get offerOut() {
@@ -17632,6 +17759,7 @@ var GhostLink = class {
 					channel.close();
 					return;
 				}
+				if (this.rtcStartedUnpinned) this.openedUnpinned.add(channel);
 				const plan = this.switcher.pending;
 				if (plan?.choices.includes("webrtc/1") && this.paired?.state.status === "ready") this.attachCandidate(channel, void 0, plan).catch(() => {});
 				else if (this.activeBinding) channel.close();
@@ -17647,6 +17775,7 @@ var GhostLink = class {
 				const was = this.lastDataLinkState;
 				traceLink(this.myPubKeyZ32, "datalink", { state });
 				this.trackDataLink(state);
+				if (state === "offering" || state === "answering") this.rtcStartedUnpinned = !options.pairing?.credentials.peerKey && !options.pairing?.credentials.expectedPeerKey;
 				if (this.activeBinding) return;
 				events.onDataLinkState?.(state);
 				if (state === "open") {
@@ -17666,9 +17795,9 @@ var GhostLink = class {
 					}
 				}
 				this.answeredAt = 0;
-				if (state === "connecting" && was === "offering" && this.offered?.epoch === this.connectionEpoch) {
+				if (state === "connecting" && was === "offering" && this.offerMade?.epoch === this.connectionEpoch) {
 					this.answeredAt = Date.now();
-					this.scheduleRace(this.offered.epoch, this.offered.at);
+					if (this.offered?.epoch === this.connectionEpoch) this.scheduleRace(this.offered.epoch, this.offered.at);
 				}
 				if (state !== "idle") return;
 				this.dialUnseen = was === "offering" && this.offerUnsent;
@@ -18259,6 +18388,7 @@ var GhostLink = class {
 		}
 		if (held && heldOn && reidentified.has(heldOn) && this.restartedRedial(held, heldOn)) return;
 		if (this.redescribedDial()) return;
+		if (!this.dialing) this.raceStandingOffer();
 		if (this.channel || this.dialing) return;
 		if (news || !again) {
 			this.autoConnectFailures = 0;
@@ -18836,6 +18966,10 @@ var GhostLink = class {
 						...resume && { resume },
 						...woke && { woke }
 					} : void 0;
+					this.offerMade = {
+						epoch,
+						at: offeredAt
+					};
 					const gate = this.dialGate;
 					this.dialGate = void 0;
 					const replaced = new Promise((resolve) => {
@@ -18847,10 +18981,12 @@ var GhostLink = class {
 						traceLink(this.myPubKeyZ32, "dial-held", {});
 						this.afterRtc = void 0;
 						this.offered = void 0;
+						this.offerMade = void 0;
 						return;
 					}
 					if (this.dataLink.state !== "idle" || epoch !== this.connectionEpoch) {
 						this.scheduleRace(epoch, offeredAt);
+						this.raceStandingOffer();
 						return;
 					}
 					this.rtcUnstarted();
@@ -19016,6 +19152,31 @@ var GhostLink = class {
 		}, Math.max(0, Math.min(...at) - now));
 	}
 	/**
+	* This side's offer went out before the contact's record was read (a joiner's early one, `dialEarly`): nothing was
+	* known of what the contact runs, so it was made with no fallback and nothing raced it. Once the record says, and both
+	* sides allow it, the offer races what both run as one made then would: answered and not connected `RACE_ANSWERED_MS`
+	* later, the relayed ones too. Behind a VPN that drops UDP, a first pairing went live over the relayed Iroh only once
+	* the attempt timed out and the next one raced, 32 to 66 s in (zero's VPN lab, 2026-10-13).
+	*/
+	raceStandingOffer() {
+		const made = this.offerMade, epoch = this.connectionEpoch;
+		if (!made || made.epoch !== epoch || this.offered?.epoch === epoch || !this.offerOut || this.channel || this.stopped) return;
+		if (!this.fallback || !this.peerFallback || !this.peerTransports) return;
+		const relayed = relayedTransports(this.localDescriptors(), this.peerDescriptors);
+		const rest = rankTransports(this.transportOffer(), this.peerTransports, relayed).filter((t) => t !== "webrtc/1");
+		if (!rest.length) return;
+		this.offered = {
+			epoch,
+			at: made.at
+		};
+		this.afterRtc = {
+			epoch,
+			rest
+		};
+		traceLink(this.myPubKeyZ32, "race-standing", { transports: rest });
+		this.scheduleRace(epoch, made.at);
+	}
+	/**
 	* 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
 	* end before it does. The direct transports both run are knocked on meanwhile, and the relayed ones where both apps
@@ -19148,6 +19309,7 @@ var GhostLink = class {
 		const left = next.rest.filter((t) => t !== "webrtc/1" && !due.includes(t));
 		if (!due.length) {
 			this.scheduleRace(epoch, offeredAt);
+			this.raceStandingOffer();
 			return;
 		}
 		this.afterRtc = left.length ? {
@@ -19172,6 +19334,7 @@ var GhostLink = class {
 		if (live || epoch !== this.connectionEpoch || this.channel || this.stopped) return;
 		if (this.dataLink.state !== "idle") {
 			this.scheduleRace(epoch, offeredAt);
+			this.raceStandingOffer();
 			return;
 		}
 		const rest = this.afterRtc;
@@ -20247,8 +20410,8 @@ var GhostLink = class {
 	* Both sides dialled at once (two apps back after a restart, each knocking): the lower key's dial carries the chat, on
 	* both sides; the higher key's side takes it over as a replacement (`attachReplacement`). Here, on the lower key's
 	* side, the contact's connection waits: dropped once this side's own dial connects, taken if that dial fails, or has
-	* not connected within `CROSSED_WAIT_MS` (the contact may be dialling an app that is not up yet, for as long as its
-	* dial takes to give up).
+	* not connected within `CROSSED_WAIT_MS` (it stalled, or goes to an endpoint the contact no longer runs, for as long
+	* as it takes to give up).
 	*/
 	crossed = null;
 	parkCrossed(channel, binding) {
@@ -20265,7 +20428,7 @@ var GhostLink = class {
 			this.dialing = false;
 			this.attempt = null;
 			this.attach(channel, binding);
-		}, CROSSED_WAIT_MS);
+		}, 500);
 		channel.onClose = () => {
 			if (this.crossed?.channel === channel) {
 				clearTimeout(timer);
@@ -20347,6 +20510,8 @@ var GhostLink = class {
 	dialedIn = /* @__PURE__ */ new WeakSet();
 	/** Connections whose session started with no key pinned nor named by the invite. */
 	openedUnpinned = /* @__PURE__ */ new WeakSet();
+	/** The WebRTC offer under way was made or answered with no key pinned nor named by the invite (its channel opens later). */
+	rtcStartedUnpinned = false;
 	/**
 	* `migration`: the channel is a candidate that takes over from the session open now once it authenticated. With a
 	* `plan`, a live switch both sides agreed; without one, a replacement (`attachReplacement`): the contact dialled
@@ -25251,6 +25416,12 @@ var byeSigned = (f) => utf8Encode(JSON.stringify([
 	f.e,
 	f.ts
 ]));
+var leftSigned = (commit) => utf8Encode(JSON.stringify([
+	"ghostly-group/1 left",
+	commit.g,
+	commit.e,
+	commitHash(commit)
+]));
 var editSigned = (f) => utf8Encode(JSON.stringify([
 	"ghostly-group/1 edit",
 	f.g,
@@ -25731,11 +25902,43 @@ var GroupSession = class {
 			}];
 		});
 	}
-	remove(memberKey, now = Date.now()) {
+	/**
+	* A welcome for a member already in the roster that never got the first one (its chat closed while it was let in):
+	* nothing is committed. It carries the secrets of the epochs it was in, from its admission on, sealed to its key.
+	*/
+	rewelcome(memberKey) {
 		return this.serialize(async () => {
 			this.requireAdmin();
 			if (!rosterHas(this.roster, memberKey) || memberKey === this.myKey) throw new Error("Not a member");
-			await this.commit("remove", memberKey, now);
+			const chain = this.state.chain;
+			let admitted = chain.length - 1;
+			while (admitted >= 0 && !(chain[admitted].k === "add" && chain[admitted].s === memberKey)) admitted--;
+			if (admitted < 0) throw new Error("Not a member");
+			const secrets = chain.slice(admitted).filter((c) => this.state.secrets[c.e] && rosterHas(c.m, memberKey)).map((c) => ({
+				e: c.e,
+				s: sealSecret(memberKey, this.secret(c.e), secretAad$1(this.id, c.e, memberKey))
+			}));
+			const pieces = chainPieces(chain);
+			const tail = pieces.pop();
+			return [...pieces.map((commits) => ({
+				t: "group-chain",
+				g: this.id,
+				commits
+			})), {
+				t: "group-welcome",
+				g: this.id,
+				name: this.name,
+				commits: tail,
+				secrets
+			}];
+		});
+	}
+	/** `left`: the member asked to leave (on the admin's chat), and the commit says so (`GroupCommitFrame.left`). */
+	remove(memberKey, now = Date.now(), { left = false } = {}) {
+		return this.serialize(async () => {
+			this.requireAdmin();
+			if (!rosterHas(this.roster, memberKey) || memberKey === this.myKey) throw new Error("Not a member");
+			await this.commit("remove", memberKey, now, left);
 		});
 	}
 	transferAdmin(memberKey, now = Date.now()) {
@@ -25752,7 +25955,7 @@ var GroupSession = class {
 			await this.commit("rotate", void 0, now);
 		});
 	}
-	async commit(kind, subject, now) {
+	async commit(kind, subject, now, left = false) {
 		if (this.hooks.adminWork?.() === false) throw new Error(GROUP_ADMIN_OFF_ERROR);
 		if (this.hooks.adminTurn && !await this.hooks.adminTurn()) throw engineError("groupTurnUnconfirmed");
 		if (this.state.chain.length >= 1024) throw new Error("This group has reached its membership history limit. Create a new group.");
@@ -25776,6 +25979,8 @@ var GroupSession = class {
 			...draft,
 			c: confirmationTag(epochKeys(secret, this.id, epoch).confirm, commitUntaggedHash(draft))
 		}, this.identity.seed);
+		const mark = left && kind === "remove" ? toBase64Url(sign(leftSigned(commit), this.identity.seed)) : void 0;
+		if (mark) (this.state.leftMarks ??= {})[epoch] = mark;
 		this.state.chain.push(commit);
 		this.chainMovedAt = this.clock();
 		this.state.secrets[epoch] = toBase64Url(secret);
@@ -25791,7 +25996,8 @@ var GroupSession = class {
 				t: "group-commit",
 				g: this.id,
 				commit,
-				...member ? { secret: sealSecret(key, secret, secretAad$1(this.id, epoch, key)) } : {}
+				...member ? { secret: sealSecret(key, secret, secretAad$1(this.id, epoch, key)) } : {},
+				...mark ? { left: mark } : {}
 			});
 		}
 		this.hooks.changed();
@@ -26191,7 +26397,7 @@ var GroupSession = class {
 					case "group-bye":
 						await this.receiveBye(from, raw);
 						break;
-					case "group-leave": if (this.isAdmin && this.hooks.adminWork?.() !== false && rosterHas(this.roster, from) && from !== this.myKey) await this.commitUnlessTurnUnconfirmed("remove", from);
+					case "group-leave": if (this.isAdmin && this.hooks.adminWork?.() !== false && rosterHas(this.roster, from) && from !== this.myKey) await this.commitUnlessTurnUnconfirmed("remove", from, true);
 				}
 				return this.state.status === "active" ? this.passOn : this.state.status === "removed" ? this.passOn.filter((f) => f.t === "group-commit") : [];
 			} finally {
@@ -26306,7 +26512,7 @@ var GroupSession = class {
 			return;
 		}
 		if (bye.e < this.admittedAt(bye.k)) return;
-		if (this.isAdmin && this.hooks.adminWork?.() !== false && await this.commitUnlessTurnUnconfirmed("remove", bye.k)) return;
+		if (this.isAdmin && this.hooks.adminWork?.() !== false && await this.commitUnlessTurnUnconfirmed("remove", bye.k, true)) return;
 		if (from !== bye.k && this.byesPassed.get(bye.k)?.sig === bye.sig) return;
 		this.byesPassed.set(bye.k, bye);
 		this.took(bye);
@@ -26331,9 +26537,9 @@ var GroupSession = class {
 	* An automatic commit (a member's leave): made, or not made when no fresh turn read says this device is the active
 	* one (`adminTurn`). Then false, and the caller goes on as a member would. Any other refusal is thrown as before.
 	*/
-	async commitUnlessTurnUnconfirmed(kind, subject) {
+	async commitUnlessTurnUnconfirmed(kind, subject, left = false) {
 		try {
-			await this.commit(kind, subject, Date.now());
+			await this.commit(kind, subject, Date.now(), left);
 			return true;
 		} catch (error) {
 			if (error instanceof EngineError && error.engineCode === "groupTurnUnconfirmed") return false;
@@ -26595,6 +26801,7 @@ var GroupSession = class {
 			const result = verifyCommit(raw, this.state.chain[e - 1] ?? null, this.id);
 			if ("error" in result || result.commit.by !== known.by) return;
 			if (commitHash(result.commit) !== commitHash(known)) await this.fork(`Member ${from.slice(0, 8)} holds a different membership history for epoch ${e}`);
+			else if (this.takeLeftMark(known, frame.left)) await this.persist();
 			return;
 		}
 		if (e > this.epoch + 1) {
@@ -26608,11 +26815,13 @@ var GroupSession = class {
 			if (result.error.startsWith("Commit does not follow") && verifyCommitSignature(raw)?.by === this.admin) await this.fork(`Member ${from.slice(0, 8)} holds a different membership history for epoch ${e}`);
 			return;
 		}
+		const mark = this.takeLeftMark(result.commit, frame.left) ? frame.left : void 0;
 		await this.apply(result.commit, frame.secret);
 		this.took({
 			t: "group-commit",
 			g: this.id,
-			commit: result.commit
+			commit: result.commit,
+			...mark ? { left: mark } : {}
 		});
 		if (this.state.status === "active" && !this.state.secrets[this.epoch]) this.ask(from);
 		const next = this.pendingCommits.get(this.epoch + 1);
@@ -26621,6 +26830,17 @@ var GroupSession = class {
 			await this.receiveCommit(from, next);
 		}
 	}
+	/** 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;
+		try {
+			if (!verify(fromBase64Url(mark), leftSigned(commit), publicKeyFromZ32(commit.by))) return false;
+		} catch {
+			return false;
+		}
+		(this.state.leftMarks ??= {})[commit.e] = mark;
+		return true;
+	}
 	async apply(commit, sealed) {
 		this.state.chain.push(commit);
 		this.chainMovedAt = this.clock();
@@ -26683,11 +26903,13 @@ var GroupSession = class {
 		const answer = [];
 		for (let e = frame.e + 1; e <= this.epoch; e++) {
 			const commit = this.state.chain[e], secret = this.secret(e);
+			const left = this.state.leftMarks?.[e];
 			answer.push({
 				t: "group-commit",
 				g: this.id,
 				commit,
-				...secret && rosterHas(commit.m, from) ? { secret: sealSecret(from, secret, secretAad$1(this.id, e, from)) } : {}
+				...secret && rosterHas(commit.m, from) ? { secret: sealSecret(from, secret, secretAad$1(this.id, e, from)) } : {},
+				...left ? { left } : {}
 			});
 		}
 		const theirs = new Set(Array.isArray(frame.secrets) ? frame.secrets.filter((n) => Number.isSafeInteger(n)) : []);
@@ -27677,6 +27899,15 @@ 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.
+	*/
+	wasExpelled(key) {
+		const i = this.outIndex(key);
+		return i >= 0 && this.state.chain[i].k === "remove";
+	}
+	/**
 	* What someone the chain took out is told when it comes back (WISP 903 § Leaving and removal): the commits from where
 	* it says it is (`sync`: its tip, or its locator) up to the one that took it out, and nothing after. Later commits
 	* are not its business (a `link` commit names the new entry key); no secret, no stored frame, no seed goes with them.
@@ -28639,7 +28870,7 @@ var CommunitySession = class {
 			return false;
 		}
 		if (!verify(fromBase64Url(raw.sig), messageSigned(raw), publicKeyFromZ32(raw.s))) return false;
-		if (this.wasRemoved(raw.s)) return false;
+		if (this.wasExpelled(raw.s)) return false;
 		const found = this.commitByShort(raw.e, raw.h);
 		if (!found) {
 			this.park(from, raw);
@@ -28883,7 +29114,7 @@ var CommunitySession = class {
 			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.wasRemoved(stored.s)) continue;
+			if (this.wasExpelled(stored.s)) 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));
@@ -30009,4 +30240,4 @@ function appStoreDecision(held, read) {
 //#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 };
 
-//# sourceMappingURL=src-_FzJkeAJ.js.map
+//# sourceMappingURL=src-CbLkHfz8.js.map