@ghostlytools/cli 1.1.4 → 1.1.6

package/dist/ghostly.mjs

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
-import { a as fileBytesOf, d as __exportAll, i as fileBytes, l as FILE_BYTES_STEP } from "./assets/fileBytes-DxiJHmTk.js";
-import { $ as checkAtprotoProofRecord, $i as replySnippet, $r as IdentityCheckUnavailable, $s as fromBase64Url$1, $t as isPubkyKey, Aa as CALL_SIGNAL_MAX_AGE_MS, Ai as parseVoiceMeta, B as sameSshKey, Bs as RELAY_PAYLOAD_MAX_BYTES, Ca as GhostlyHttpError, Cn as resolveLightningDestination, Ct as parseDidSignaturePaste, Da as LIMITS, Di as VOICE_LIMITS, Ei as PLAYABLE_AUDIO, En as decodeBolt11, Et as strictBase64Url, Fa as callSignalHeardAt, G as decodeAnyBitcoinAddress, H as verifySshSignature, I as SSHSIG_NAMESPACE, Ia as extractParamsFromSdp, Ir as BUTTONS_CAPABILITY, J as ATPROTO_PROOF_COLLECTION, K as ATPROTO_DECLARED_SCOPE, Kt as walletNetworkOf, L as SshSigError, La as parseCallSignal, Ma as answersOffer, Na as buildSdpFromSignal, Oi as baseMime, P as groupName, Pa as callRtcConfig, Pr as checkPushEndpoint, Ps as setLinkTraceSink, Q as atprotoProofRkey, Qt as PUBKY_PROOF_MAX_BYTES, R as parseSshPublicKey, Ra as signalHasVideo, Si as readImageMeta, Sn as requestLnurlInvoice, St as parseDidDocument, Ti as sanitizeMime, Tn as engineText, Tt as staticDidDocument, U as verifyBitcoinMessage, Us as openRelayPayload, V as sshSignCommand, Vt as WALLET_NETWORKS, W as BitcoinAddressError, X as atprotoDidMethod, Xs as MAX_AVATAR_LENGTH, Y as ATPROTO_PROOF_SCOPE, Z as atprotoProofRecord, Zs as sanitizeAvatar, _n as recordsFromTxt, _t as didWebFileNames, aa as checkStatusCard, an as pubkyProofPath, at as verifyAtprotoRecordProof, bn as txtValue, bt as normalizeDid, cn as DOMAIN_FILE_MAX_BYTES, dn as domainTxtRecord, dt as checkDidSignature, ec as randomBytes$1, en as isPubkyProofFolder, et as isAtprotoDid, fn as domainWellKnownFile, ft as didGhostlyServiceEntry, gn as normalizeDomain, gr as TYPING_REFRESH_MS, gt as didWebFile, hn as nip05RootKey, hr as TYPING_KINDS, ht as didWebDocumentUrl, ia as buttonLabelClash, ic as utf8Encode, ii as identityStatement, in as pubkyProofFile, it as AtprotoProofError, ja as RTC_CONFIG, ji as voicePeaksOf, jt as resolveDidDht, ln as decodeDnsResponse, lt as DidError, mn as isPublicAddress, mt as didSignedMessages, na as RUN_RESULTS, nn as normalizePubkyKey, nt as parseAtprotoDidDocument, on as homeserverWebEndpoint, ot as DID_DOCUMENT_MAX_BYTES$1, pn as encodeDnsQuery, pt as didJwsAlg, q as ATPROTO_FULL_SCOPE, ra as STATUS_CARD_LIMITS, rc as utf8Decode, rn as pubkyProofCapability, rs as inviteLink, rt as shortAtprotoDid, sn as pubkyHomeserverOf, st as DID_FILE_MAX_BYTES, ta as ITEM_STATES, tc as toBase64Url$1, ti as boundVerifiedIdentity, tn as newPubkyProofFolder, tt as normalizeAtprotoHandle, un as dnsProofName, ut as checkDidJws, vn as recordsFromWellKnown, vr as sanitizeTypingStatus, vt as didWebFileUrl, wi as sanitizeFileName, wn as engineError, wt as signingKeys, xn as wellKnownUrl, xt as parseDid, yn as recordsName, yt as didWebHost, z as parseSshSignature } from "./assets/src-K3NijMq-.js";
-import { d as wrap, i as databaseName, l as store$1, n as STORES, o as fileStore, s as openDb, u as transact } from "./assets/idb-Co2lObpU.js";
+import { t as __exportAll } from "./assets/rolldown-runtime-8H4AJuhK.js";
+import { $ as parseSshPublicKey, $a as signAppRevocation, $n as GROUP_FILE_LIMITS, Aa as replySnippet, An as nip05RootKey, At as didWebDocumentUrl, Bc as sanitizeAvatar, Bn as engineText, Bt as staticDidDocument, Cc as setLinkTraceSink, Cn as DOMAIN_FILE_MAX_BYTES, Co as callRtcConfig, Dn as domainWellKnownFile, Do as signalHasVideo, Dt as didGhostlyServiceEntry, En as domainTxtRecord, Eo as parseCallSignal, Et as checkDidSignature, Fa as buttonLabelClash, Fn as txtValue, Ft as normalizeDid, Ga as APP_STATEMENT_LIMITS, Gc as toZ32, Gi as irohRelayUrl, Hc as fromBase64Url$1, Hr as TYPING_REFRESH_MS, Ia as checkStatusCard, In as wellKnownUrl, It as parseDid, Ja as checkAppRevokeStatement, Ka as appFingerprint, Kc as utf8Decode, Ks as inviteLink, Kt as resolveDidDht, Ln as requestLnurlInvoice, Lr as ChatFiles, Lt as parseDidDocument, Ma as ITEM_STATES, Mc as openRelayPayload, Mn as recordsFromTxt, Mt as didWebFileNames, Na as RUN_RESULTS, Nn as recordsFromWellKnown, Nt as didWebFileUrl, On as encodeDnsQuery, Ot as didJwsAlg, Pa as STATUS_CARD_LIMITS, Pi as identityStatement, Pn as recordsName, Pt as didWebHost, Q as SshSigError, Qa as signAppObject, Qi as readImageMeta, Rn as resolveLightningDestination, Rt as parseDidSignaturePaste, Sn as pubkyHomeserverOf, So as buildSdpFromSignal, St as DID_FILE_MAX_BYTES, Tn as dnsProofName, To as extractParamsFromSdp, Tt as checkDidJws, Uc as randomBytes$1, Vn as decodeBolt11, Vr as TYPING_KINDS, Vt as strictBase64Url, Wa as APP_PREFIXES, Wc as toBase64Url$1, Wi as irohDescriptor, Wr as sanitizeTypingStatus, Y as groupName, Z as SSHSIG_NAMESPACE, Za as readAppRevocations, _n as normalizePubkyKey, _t as parseAtprotoDidDocument, a as checkAppStoreIndex, aa as baseMime, ar as isGroupMessageId, at as BitcoinAddressError, bn as pubkyProofPath, bo as RTC_CONFIG, bt as verifyAtprotoRecordProof, c as APP_BUNDLE_LIMITS, ca as voicePeaksOf, cr as readGroupWant, ct as ATPROTO_FULL_SCOPE, di as BUTTONS_CAPABILITY, dt as atprotoDidMethod, eo as canonicalJson, er as GROUP_HAVE_FRAME, et as parseSshSignature, f as assembleAppBundle, fa as RateWindow, fo as GhostlyHttpError, ft as atprotoProofRecord, gn as newPubkyProofFolder, go as LIMITS, gt as normalizeAtprotoHandle, h as readAppBundle, hn as isPubkyProofFolder, ht as isAtprotoDid, ia as VOICE_LIMITS, ir as groupFileFallback, it as verifyBitcoinMessage, ji as boundVerifiedIdentity, jn as normalizeDomain, jt as didWebFile, kc as RELAY_PAYLOAD_MAX_BYTES, ki as IdentityCheckUnavailable, kn as isPublicAddress, kt as didSignedMessages, lr as readGroupWantNo, lt as ATPROTO_PROOF_COLLECTION, m as isAppUrl, mn as isPubkyKey, mt as checkAtprotoProofRecord, na as sanitizeMime, nn as WALLET_NETWORKS, nr as GROUP_WANT_NO_FRAME, nt as sshSignCommand, o as readAppStore, oa as fileMessageText, oi as checkPushEndpoint, ot as decodeAnyBitcoinAddress, p as checkAppManifest, pn as PUBKY_PROOF_MAX_BYTES, pt as atprotoProofRkey, qa as appRef, qc as utf8Encode, ra as PLAYABLE_AUDIO, rc as seedSigner, rr as fetchesByItself, rt as verifySshSignature, s as signAppStore, sa as parseVoiceMeta, sn as walletNetworkOf, sr as readGroupHave, st as ATPROTO_DECLARED_SCOPE, t as appStoreDecision, ta as sanitizeFileName, to as canonicalJsonBytes, tt as sameSshKey, ut as ATPROTO_PROOF_SCOPE, vn as pubkyProofCapability, vt as shortAtprotoDid, wn as decodeDnsResponse, wo as callSignalHeardAt, wt as DidError, xn as homeserverWebEndpoint, xo as answersOffer, xt as DID_DOCUMENT_MAX_BYTES$1, yn as pubkyProofFile, yo as CALL_SIGNAL_MAX_AGE_MS, yt as AtprotoProofError, zc as MAX_AVATAR_LENGTH, zn as engineError, zr as transferEnded, zt as signingKeys } from "./assets/src-DtxVo2Rm.js";
+import { c as fileStore, d as store$1, f as transact, i as STORES, l as openDb, o as databaseName, p as wrap } from "./assets/idb-BIdus0WX.js";
+import { a as fileBytesOf, i as fileBytes, l as FILE_BYTES_STEP } from "./assets/fileBytes-3AQ2tJzW.js";
 import { createRequire } from "node:module";
 import { spawn } from "node:child_process";
 import { connect, createServer, isIP } from "node:net";
@@ -17,7 +18,7 @@ import { decode, npubEncode } from "nostr-tools/nip19";
 import { BunkerSigner } from "nostr-tools/nip46";
 import { SimplePool } from "nostr-tools/pool";
 import { generateSecretKey } from "nostr-tools/pure";
-import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
+import { createHash, createPrivateKey, generateKeyPairSync, randomBytes, timingSafeEqual } from "node:crypto";
 import { createServer as createServer$1 } from "node:http";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
@@ -34,7 +35,7 @@ import { IDBFactory, IDBKeyRange as IDBKeyRange$1, IDBTransaction } from "fake-i
 import { format } from "node:util";
 var package_default = {
 	name: "@ghostlytools/cli",
-	version: "1.1.4",
+	version: "1.1.6",
 	type: "module",
 	description: "Ghostly for bots and terminals: the app's own engine, headless on Node, behind a daemon and a `ghostly` command with JSON output.",
 	license: "MIT",
@@ -595,6 +596,10 @@ var ENGINE_METHODS = [
 	"retryMessage",
 	"react",
 	"pinMessage",
+	"appId",
+	"appOpen",
+	"appClose",
+	"appSend",
 	"messageDetails",
 	"deleteMessage",
 	"exportLinks",
@@ -669,6 +674,7 @@ var ENGINE_METHODS = [
 	"disableGroupLink",
 	"joinGroupByLink",
 	"sendGroupMessage",
+	"sendGroupFile",
 	"pressButton",
 	"groupMessages",
 	"messagePage",
@@ -713,7 +719,27 @@ var ENGINE_METHODS = [
 	"deviceSetNoticeSeen",
 	"deviceTurnCheck",
 	"devicePushState",
-	"devicePushSet"
+	"devicePushSet",
+	"appList",
+	"appStoreList",
+	"appStorePreview",
+	"appStoreAdd",
+	"appStoreRemove",
+	"appStoreRefresh",
+	"appPreview",
+	"appInstall",
+	"appUpdateAccept",
+	"appCheckUpdates",
+	"appUninstall",
+	"appRunCheck",
+	"appFetchFiles",
+	"appEntry",
+	"appFile",
+	"appStorageGet",
+	"appStorageSet",
+	"appStorageDelete",
+	"appStorageKeys",
+	"appDataExport"
 ];
 /** Reads the hosts use outside `EngineApi`: the whole state, and one chat's stored messages. */
 var ENGINE_READS = ["getState", "getMessages"];
@@ -1015,6 +1041,707 @@ function groupReply(reply, myKey) {
 	};
 }
 //#endregion
+//#region ../browser/src/engine/groupFiles.ts
+/** A group file's local id: its group's and a random part, never anything a member sends. */
+var groupFileId = (groupId, direction, random = toBase64Url$1(randomBytes$1(12))) => `group-${groupId}-${direction}-${random}`;
+/** The group a local file id names, among `groupIds`. */
+var groupOfFile = (fileId, groupIds) => [...groupIds].find((g) => fileId.startsWith(`group-${g}-in-`) || fileId.startsWith(`group-${g}-out-`));
+/** What a file's message says: its caption, or (when the author wrote none) the file itself, not the line older apps show. */
+var groupFileText = (text, meta) => text === groupFileFallback(meta) ? fileMessageText(meta) : text;
+/** The profile's files store and file storage, as a 1:1 chat's files use them. */
+var storedGroupFiles = {
+	list: (groupId) => fileStore.listForLink(`group:${groupId}`),
+	get: (id) => fileStore.get(id),
+	put: (file) => fileStore.put(file),
+	patch: (id, fields) => fileStore.patch(id, fields),
+	remove: (id) => removeStored(id),
+	async write(id) {
+		const stored = await fileStore.get(id);
+		const bytes = stored?.bytes && await fileBytesOf(stored.bytes) || await fileBytes();
+		if (await bytes.size(id) !== null) await bytes.truncate(id, 0);
+		if (stored && stored.bytes !== bytes.kind) await fileStore.patch(id, { bytes: bytes.kind });
+		const appender = new FileAppender(bytes, id, 0);
+		return {
+			append: (chunk) => appender.append(chunk),
+			flush: () => appender.flush(),
+			digest: async () => {
+				await appender.close();
+				return bytes.digest(id);
+			},
+			discard: async () => {
+				await appender.close().catch(() => {});
+				await bytes.remove(id);
+			}
+		};
+	},
+	read: (file, offset, length) => readStored(file, offset, length),
+	room: async () => (await fileBytes()).room()
+};
+/** Why a want waits, as the person reads it. */
+var NOBODY_CONNECTED = "Nobody you are connected to has this file yet";
+var GroupFileDesk = class {
+	deps;
+	kept = /* @__PURE__ */ new Map();
+	/** `<group>\n<message id>` → local id. */
+	byMessage = /* @__PURE__ */ new Map();
+	wants = /* @__PURE__ */ new Map();
+	edgesById = /* @__PURE__ */ new Map();
+	/** My file about to be announced, by `<group>\n<digest>`: the message that announces it takes this local id. */
+	own = /* @__PURE__ */ new Map();
+	/** Announcements sent per group, and taken per member of a group (WISP 503 § Rules for both, Pace). */
+	sentPace = /* @__PURE__ */ new Map();
+	takenPace = /* @__PURE__ */ new Map();
+	/** `<group>\n<message id>` a `group-have` named before its message came → its holders, newest first. */
+	ahead = /* @__PURE__ */ new Map();
+	/** A community's ids for its next `group-have`, and when one last went. */
+	communityHave = /* @__PURE__ */ new Map();
+	/** Bytes served today, and the day (UTC days since the epoch). */
+	served = {
+		day: 0,
+		bytes: 0
+	};
+	constructor(deps) {
+		this.deps = deps;
+	}
+	/** At start: each group's files as they were kept. One fetched by itself, or asked for, and not here yet is asked for again. */
+	async load(groupIds) {
+		for (const groupId of groupIds) for (const file of await this.deps.store.list(groupId).catch(() => [])) {
+			if (!file.group || !file.metadata || !file.digest || this.kept.has(file.id)) continue;
+			const { name, size, mime, voice, video, image } = file.metadata;
+			const kept = {
+				id: file.id,
+				groupId,
+				message: file.group.message,
+				author: file.group.author,
+				meta: {
+					name,
+					size,
+					mime,
+					d: file.digest,
+					...voice && { voice },
+					...video && { video },
+					...image && { image }
+				},
+				mine: file.direction === "out",
+				auto: !!file.group.auto,
+				asked: !!file.group.asked,
+				held: file.transfer?.state === "done",
+				holders: []
+			};
+			this.add(kept);
+			if (kept.held) this.show(kept, {
+				state: "done",
+				transferred: size,
+				size,
+				direction: kept.mine ? "out" : "in"
+			});
+			else if (kept.auto || kept.asked) this.wants.set(kept.id, this.newWant());
+			else this.show(kept, {
+				state: "transferring",
+				stage: "asking",
+				transferred: 0,
+				size,
+				direction: "in"
+			});
+		}
+		for (const [id] of this.wants) this.ask(this.kept.get(id));
+		this.deps.changed();
+	}
+	/** An error when this group took as many announcements of mine as it takes in a minute; null when one may go now. */
+	mayAnnounce(groupId) {
+		return this.pace(this.sentPace, groupId, GROUP_FILE_LIMITS.announcePerMinute, 6e4).wait() ? "You sent many files to this group just now. Wait a minute." : null;
+	}
+	/** My file, stored under `fileId` with the author's digest, is about to be announced in the group: its message takes it. */
+	outgoing(groupId, fileId, meta) {
+		this.own.set(`${groupId}\n${meta.d}`, fileId);
+	}
+	/** The announcement did not go: the file is not this group's after all. */
+	notSent(groupId, meta) {
+		this.own.delete(`${groupId}\n${meta.d}`);
+	}
+	/**
+	* A message of the group announces a file (mine, or a member's): the file its row shows, or none when the member
+	* announced more than the group takes (its text shows). A member's is kept here unfetched, and fetched now when it is
+	* one this device takes by itself. The same message again (a catch-up, a whole copy) is the same file.
+	*/
+	async announced(groupId, m, me) {
+		const known = this.byMessage.get(`${groupId}\n${m.id}`);
+		if (known) return messageFile(this.kept.get(known));
+		const ownId = m.sender === me ? this.own.get(`${groupId}\n${m.file.d}`) : void 0;
+		if (ownId) {
+			this.own.delete(`${groupId}\n${m.file.d}`);
+			this.pace(this.sentPace, groupId, GROUP_FILE_LIMITS.announcePerMinute, 6e4).take();
+			const kept = {
+				id: ownId,
+				groupId,
+				message: m.id,
+				author: me,
+				meta: m.file,
+				mine: true,
+				auto: false,
+				asked: false,
+				held: true,
+				holders: []
+			};
+			this.add(kept);
+			const transfer = {
+				state: "done",
+				transferred: m.file.size,
+				size: m.file.size
+			};
+			await this.deps.store.patch(ownId, {
+				group: {
+					message: m.id,
+					author: me
+				},
+				transfer
+			}).catch(() => {});
+			this.show(kept, {
+				...transfer,
+				direction: "out"
+			});
+			this.queueHave(kept);
+			return messageFile(kept);
+		}
+		if (!this.pace(this.takenPace, `${groupId}\n${m.sender}`, GROUP_FILE_LIMITS.announceTaken, GROUP_FILE_LIMITS.announceWindowMs).take()) return void 0;
+		const id = groupFileId(groupId, "in");
+		const auto = this.deps.settings().autoDownloads && fetchesByItself(m.file, this.keptAutomatically(groupId));
+		const holders = this.ahead.get(`${groupId}\n${m.id}`) ?? [];
+		this.ahead.delete(`${groupId}\n${m.id}`);
+		const kept = {
+			id,
+			groupId,
+			message: m.id,
+			author: m.sender,
+			meta: m.file,
+			mine: false,
+			auto,
+			asked: false,
+			held: false,
+			holders
+		};
+		const { name, size, mime, voice, video, image } = m.file;
+		this.add(kept);
+		await this.deps.store.put({
+			id,
+			linkId: `group:${groupId}`,
+			direction: "in",
+			digest: m.file.d,
+			createdAt: this.deps.now(),
+			metadata: {
+				name,
+				size,
+				mime,
+				timestamp: this.deps.now(),
+				voice,
+				video,
+				image
+			},
+			transfer: {
+				state: "transferring",
+				transferred: 0,
+				size
+			},
+			group: {
+				message: m.id,
+				author: m.sender,
+				...auto && { auto: true }
+			}
+		});
+		if (auto) {
+			this.wants.set(id, this.newWant());
+			this.ask(kept);
+		} else this.show(kept, {
+			state: "transferring",
+			stage: "asking",
+			transferred: 0,
+			size,
+			direction: "in"
+		});
+		return messageFile(kept);
+	}
+	/** The person asks for a file this device did not fetch by itself (Download), or for one that stopped coming. */
+	async download(fileId) {
+		const kept = this.kept.get(fileId);
+		if (!kept) throw new Error("No such file");
+		if (kept.held) return;
+		const room = await this.deps.store.room().catch(() => null);
+		if (room !== null && kept.meta.size > room) throw new Error("Not enough space on this device for this file");
+		if (!kept.asked) {
+			kept.asked = true;
+			await this.deps.store.patch(kept.id, { group: this.groupField(kept) }).catch(() => {});
+		}
+		const want = this.wants.get(kept.id);
+		if (!want) this.wants.set(kept.id, this.newWant());
+		else if (!want.wire) want.tried.clear();
+		this.ask(kept);
+	}
+	/** The group is gone from this device: its files go too. */
+	async drop(groupId) {
+		for (const kept of [...this.kept.values()].filter((k) => k.groupId === groupId)) {
+			this.kept.delete(kept.id);
+			this.byMessage.delete(`${groupId}\n${kept.message}`);
+			this.wants.delete(kept.id);
+			this.deps.transfers.delete(kept.id);
+			await this.deps.store.remove(kept.id).catch(() => {});
+		}
+		for (const [linkId, edge] of this.edgesById) if (edge.groupId === groupId) {
+			edge.files.detach();
+			this.edgesById.delete(linkId);
+		}
+		for (const key of [...this.ahead.keys()]) if (key.startsWith(`${groupId}\n`)) this.ahead.delete(key);
+		this.communityHave.delete(groupId);
+		this.deps.changed();
+	}
+	/** An edge's files/3 session opened (both sides agreed it) or closed. */
+	session(groupId, peer, linkId, open) {
+		const edge = this.edge(groupId, peer, linkId);
+		if (open) edge.files.attach();
+		else edge.files.detach();
+		if (open) this.retry(groupId);
+	}
+	/** An edge came up and both sides said where they are: what this device holds goes to it, and wants waiting for a holder go. */
+	edgeReady(groupId, peer, linkId) {
+		if (!this.deps.ready(linkId)) return;
+		const edge = this.edge(groupId, peer, linkId);
+		if (this.deps.settings().serveFiles) {
+			const held = [...this.kept.values()].filter((k) => k.groupId === groupId && k.held).map((k) => k.message).slice(-GROUP_FILE_LIMITS.haveIds);
+			if (held.length) this.sendHave(edge, held);
+		}
+		this.retry(groupId);
+	}
+	/** A `group-want`, `group-want-no` or `group-have` on an edge, from the member it is pinned to. */
+	async frame(groupId, peer, linkId, frame) {
+		if (frame.t === "group-want") {
+			const want = readGroupWant(frame, groupId);
+			if (want) await this.serve(this.edge(groupId, peer, linkId), want.id);
+		} else if (frame.t === "group-want-no") {
+			const no = readGroupWantNo(frame, groupId);
+			if (no) this.refused(groupId, peer, linkId, no.id, no.why);
+		} else if (frame.t === "group-have") {
+			const ids = readGroupHave(frame, groupId);
+			if (ids) this.heard(groupId, peer, ids);
+		}
+	}
+	/** A community's `group-have`, an application frame its signer sent the group. */
+	communityApp(groupId, sender, frame) {
+		const ids = readGroupHave(frame);
+		if (ids) this.heard(groupId, sender, ids);
+	}
+	/**
+	* A files/3 frame on an edge. An offer is taken only for a file this device asked that member for (`gm` naming the
+	* message): nobody can push a file into another's storage. What it brings belongs to the group's message, not to the
+	* edge as a chat.
+	*/
+	filesFrame(groupId, peer, linkId, frame) {
+		const edge = this.edge(groupId, peer, linkId);
+		if (frame.t === "pf-offer" && typeof frame.id === "string" && /^[A-Za-z0-9_-]{8,64}$/.test(frame.id) && !edge.taking.has(frame.id)) {
+			const kept = isGroupMessageId(frame.gm) ? this.kept.get(this.byMessage.get(`${groupId}\n${frame.gm}`) ?? "") : void 0;
+			const want = kept && this.wants.get(kept.id);
+			if (!kept || kept.held || !want || want.linkId !== linkId || want.wire) {
+				this.deps.sendFiles(linkId, {
+					t: "pf-refuse",
+					id: frame.id,
+					why: "invalid"
+				});
+				return Promise.resolve();
+			}
+			edge.taking.set(frame.id, kept.id);
+			want.wire = frame.id;
+			want.movedAt = this.deps.now();
+		}
+		return edge.files.handle(frame);
+	}
+	/** Wants that waited too long for an offer, or for bytes, go to the next holder; `group-have`s gathered go. */
+	tick() {
+		const now = this.deps.now();
+		for (const [id, want] of this.wants) {
+			const kept = this.kept.get(id);
+			if (!kept) {
+				this.wants.delete(id);
+				continue;
+			}
+			if (now - (want.wire ? want.movedAt : want.at) < GROUP_FILE_LIMITS.wantWaitMs) continue;
+			if (want.wire) {
+				const edge = want.linkId ? this.edgesById.get(want.linkId) : void 0;
+				if (edge?.files.get("in", want.wire) && !transferEnded(edge.files.get("in", want.wire))) {
+					edge.files.cancel("in", want.wire);
+					continue;
+				}
+				want.wire = void 0;
+			}
+			if (want.holder) want.tried.add(want.holder);
+			else want.tried.clear();
+			this.ask(kept);
+		}
+		for (const edge of this.edgesById.values()) {
+			if (!edge.have.size || now - edge.haveAt < GROUP_FILE_LIMITS.haveEveryMs || !this.deps.ready(edge.linkId)) continue;
+			this.sendHave(edge, [...edge.have]);
+		}
+		for (const [groupId, have] of this.communityHave) {
+			if (!have.ids.size || now - have.at < GROUP_FILE_LIMITS.communityHaveEveryMs) continue;
+			const ids = [...have.ids].slice(-GROUP_FILE_LIMITS.haveIds);
+			have.ids.clear();
+			have.at = now;
+			this.deps.sendApp(groupId, {
+				t: GROUP_HAVE_FRAME,
+				ids
+			}).catch(() => {});
+		}
+	}
+	newWant() {
+		return {
+			at: this.deps.now(),
+			tried: /* @__PURE__ */ new Set(),
+			moved: 0,
+			movedAt: 0
+		};
+	}
+	/** Wants of this group that wait for a holder: asked now (an edge came up, or a member said it holds something). */
+	retry(groupId) {
+		for (const [id, want] of this.wants) {
+			const kept = this.kept.get(id);
+			if (kept?.groupId === groupId && !want.holder) this.ask(kept);
+		}
+	}
+	/**
+	* Asks the next holder for a file: the author first while its edge is up, then the holders whose edge is up. Only over
+	* an edge this device has. (A private group past 16 members, or a community, reaches a holder it has no edge with
+	* over a file session of the two members, WISP 503 § The file session; that session is not built yet, so such a
+	* holder is not asked, and the file waits for one that is reachable.)
+	*/
+	ask(kept) {
+		const want = this.wants.get(kept.id);
+		if (!want || kept.held || want.wire) return;
+		const membership = this.deps.membership(kept.groupId);
+		const edges = this.deps.edges(kept.groupId);
+		const order = [kept.author, ...kept.holders.filter((key) => key !== kept.author)].filter((key) => membership && key !== membership.me && membership.inRoster(key) && !want.tried.has(key));
+		for (const key of order) {
+			const linkId = edges.get(key);
+			if (!linkId || !this.deps.ready(linkId) || !this.edgesById.get(linkId)?.files.live) continue;
+			if (!this.deps.send(linkId, {
+				t: "group-want",
+				g: kept.groupId,
+				id: kept.message
+			})) {
+				want.tried.add(key);
+				continue;
+			}
+			Object.assign(want, {
+				holder: key,
+				linkId,
+				at: this.deps.now()
+			});
+			this.show(kept, {
+				state: "transferring",
+				stage: "queued",
+				transferred: 0,
+				size: kept.meta.size,
+				direction: "in"
+			});
+			return;
+		}
+		Object.assign(want, {
+			holder: void 0,
+			linkId: void 0,
+			at: this.deps.now()
+		});
+		this.show(kept, {
+			state: "transferring",
+			stage: "waiting",
+			transferred: 0,
+			size: kept.meta.size,
+			direction: "in",
+			note: NOBODY_CONNECTED
+		});
+	}
+	/** A holder's no: the next one is asked. One that deleted the file is no holder any more. */
+	refused(groupId, peer, linkId, messageId, why) {
+		const kept = this.kept.get(this.byMessage.get(`${groupId}\n${messageId}`) ?? "");
+		const want = kept && this.wants.get(kept.id);
+		if (!kept || !want || want.linkId !== linkId || want.wire) return;
+		if (why === "gone") kept.holders = kept.holders.filter((key) => key !== peer);
+		want.tried.add(peer);
+		want.holder = want.linkId = void 0;
+		this.ask(kept);
+	}
+	/** A member says it holds these files: remembered as a holder of each (newest first), and asked when a want waits. */
+	heard(groupId, from, ids) {
+		const membership = this.deps.membership(groupId);
+		if (!membership || from === membership.me || !membership.inRoster(from)) return;
+		const newest = (holders) => [from, ...holders.filter((key) => key !== from)].slice(0, GROUP_FILE_LIMITS.holders);
+		for (const message of ids) {
+			const key = `${groupId}\n${message}`, kept = this.kept.get(this.byMessage.get(key) ?? "");
+			if (!kept) {
+				this.ahead.set(key, newest(this.ahead.get(key) ?? []));
+				if (this.ahead.size > GROUP_FILE_LIMITS.heardAhead) this.ahead.delete(this.ahead.keys().next().value);
+				continue;
+			}
+			if (kept.mine) continue;
+			kept.holders = newest(kept.holders);
+			const want = this.wants.get(kept.id);
+			if (!want) continue;
+			want.tried.delete(from);
+			if (!want.holder) this.ask(kept);
+		}
+	}
+	/** A member asks for a file: offered over files/3 on its edge, or a `group-want-no` saying why not. */
+	async serve(edge, messageId) {
+		const kept = this.kept.get(this.byMessage.get(`${edge.groupId}\n${messageId}`) ?? "");
+		const here = !!kept?.held && !!await this.deps.store.get(kept.id).catch(() => void 0);
+		const why = this.mayServe(edge, messageId, here ? kept : void 0);
+		if (why || !kept) {
+			this.deps.send(edge.linkId, {
+				t: GROUP_WANT_NO_FRAME,
+				g: edge.groupId,
+				id: messageId,
+				why: why ?? "gone"
+			});
+			return;
+		}
+		const wire = toBase64Url$1(randomBytes$1(12));
+		edge.serving.set(wire, kept.id);
+		const { name, mime, size, voice, video, image } = kept.meta;
+		const file = {
+			id: wire,
+			name,
+			mime,
+			size,
+			timestamp: this.deps.now(),
+			...voice && { voice },
+			...video && { video },
+			...image && { image }
+		};
+		edge.files.offer(file, kept.meta.d);
+	}
+	/**
+	* Why this device does not serve a file now, or null when it does (WISP 503 § Asking, Serving limits): `refused` to
+	* someone who could not read the announcement, `gone` when it is not here (`kept` undefined), `busy` when serving is
+	* off or full.
+	*/
+	mayServe(edge, messageId, kept) {
+		const membership = this.deps.membership(edge.groupId);
+		if (!membership || !membership.couldRead(edge.peer, messageId)) return "refused";
+		if (!kept) return "gone";
+		if (!this.deps.settings().serveFiles || !edge.files.live) return "busy";
+		const active = this.servingNow();
+		if (active.length >= GROUP_FILE_LIMITS.serveAtOnce || active.some((a) => a.peer === edge.peer)) return "busy";
+		const today = Math.floor(this.deps.now() / 864e5);
+		if (this.served.day !== today) this.served = {
+			day: today,
+			bytes: 0
+		};
+		const reserved = active.reduce((sum, a) => sum + a.size, 0);
+		return this.served.bytes + reserved + kept.meta.size > GROUP_FILE_LIMITS.serveBytesPerDay ? "busy" : null;
+	}
+	/** Transfers served now, all groups together: to whom, and their size. */
+	servingNow() {
+		const active = [];
+		for (const edge of this.edgesById.values()) for (const wire of edge.serving.keys()) {
+			const record = edge.files.get("out", wire);
+			if (record && !transferEnded(record)) active.push({
+				peer: edge.peer,
+				size: record.file.size
+			});
+		}
+		return active;
+	}
+	/** Says on an edge which files this device holds. */
+	sendHave(edge, ids) {
+		for (let i = 0; i < ids.length; i += GROUP_FILE_LIMITS.haveIds) if (!this.deps.send(edge.linkId, {
+			t: "group-have",
+			g: edge.groupId,
+			ids: ids.slice(i, i + GROUP_FILE_LIMITS.haveIds)
+		})) return;
+		edge.have.clear();
+		edge.haveAt = this.deps.now();
+	}
+	/** This device holds a new file: the group hears it with the next `group-have` (batched, `haveEveryMs` at most on an edge). */
+	queueHave(kept) {
+		if (!this.deps.settings().serveFiles) return;
+		if (this.deps.membership(kept.groupId)?.community) {
+			let have = this.communityHave.get(kept.groupId);
+			if (!have) this.communityHave.set(kept.groupId, have = {
+				ids: /* @__PURE__ */ new Set(),
+				at: 0
+			});
+			have.ids.add(kept.message);
+			return;
+		}
+		for (const [key, linkId] of this.deps.edges(kept.groupId)) this.edge(kept.groupId, key, linkId).have.add(kept.message);
+	}
+	edge(groupId, peer, linkId) {
+		const known = this.edgesById.get(linkId);
+		if (known) return known;
+		const edge = {
+			linkId,
+			groupId,
+			peer,
+			files: void 0,
+			serving: /* @__PURE__ */ new Map(),
+			taking: /* @__PURE__ */ new Map(),
+			have: /* @__PURE__ */ new Set(),
+			haveAt: 0
+		};
+		edge.files = new ChatFiles({
+			send: (frame) => {
+				const kept = frame.t === "pf-offer" ? this.kept.get(edge.serving.get(frame.id) ?? "") : void 0;
+				return this.deps.sendFiles(linkId, kept ? {
+					...frame,
+					gm: kept.message
+				} : frame);
+			},
+			decide: (file) => this.decide(edge, file),
+			openTarget: (record) => this.openTarget(edge, record),
+			openSource: (record) => this.openSource(edge, record),
+			changed: (record, transferred) => this.transferChanged(edge, record, transferred),
+			room: () => this.deps.store.room(),
+			writable: () => this.deps.writable?.(linkId)
+		});
+		this.edgesById.set(linkId, edge);
+		return edge;
+	}
+	/** An offer that answers my want (`filesFrame` checked that): taken, unless it is not the file announced or there is no room. */
+	async decide(edge, file) {
+		const kept = this.kept.get(edge.taking.get(file.id) ?? ""), want = kept && this.wants.get(kept.id);
+		if (!kept || kept.held || want?.linkId !== edge.linkId || want.wire !== file.id || file.size !== kept.meta.size) return { refuse: "invalid" };
+		const room = await this.deps.store.room().catch(() => null);
+		return room !== null && file.size > room ? {
+			refuse: "no-room",
+			room
+		} : "accept";
+	}
+	async openTarget(edge, record) {
+		const kept = this.kept.get(edge.taking.get(record.id) ?? "");
+		if (!kept) throw new Error("No such file");
+		await kept.idle;
+		const writer = await this.deps.store.write(kept.id);
+		return {
+			offset: 0,
+			append: (bytes) => writer.append(bytes),
+			flush: () => writer.flush(),
+			verify: async () => await writer.digest() === kept.meta.d,
+			discard: () => kept.idle = writer.discard().catch(() => {})
+		};
+	}
+	async openSource(edge, record) {
+		const kept = this.kept.get(edge.serving.get(record.id) ?? "");
+		const stored = kept && await this.deps.store.get(kept.id);
+		if (!kept || !stored) throw new Error("The file is gone");
+		return {
+			read: (offset, length) => this.deps.store.read(stored, offset, length),
+			digest: async () => kept.meta.d
+		};
+	}
+	transferChanged(edge, record, transferred) {
+		if (record.direction === "out") {
+			if (transferEnded(record) && edge.serving.has(record.id)) {
+				const today = Math.floor(this.deps.now() / 864e5);
+				if (this.served.day !== today) this.served = {
+					day: today,
+					bytes: 0
+				};
+				this.served.bytes += record.confirmed;
+				edge.serving.delete(record.id);
+			}
+			return;
+		}
+		const kept = this.kept.get(edge.taking.get(record.id) ?? ""), want = kept && this.wants.get(kept.id);
+		if (!kept || !want || want.wire !== record.id || want.linkId !== edge.linkId) return;
+		if (transferred !== want.moved) {
+			want.moved = transferred;
+			want.movedAt = this.deps.now();
+		}
+		const { size } = kept.meta;
+		switch (record.state) {
+			case "done":
+				kept.held = true;
+				this.wants.delete(kept.id);
+				edge.taking.delete(record.id);
+				this.deps.store.patch(kept.id, { transfer: {
+					state: "done",
+					transferred: size,
+					size
+				} }).catch(() => {});
+				this.show(kept, {
+					state: "done",
+					transferred: size,
+					size,
+					direction: "in"
+				});
+				this.queueHave(kept);
+				return;
+			case "failed":
+			case "declined":
+			case "cancelled":
+				edge.taking.delete(record.id);
+				if (want.holder) want.tried.add(want.holder);
+				Object.assign(want, {
+					wire: void 0,
+					holder: void 0,
+					linkId: void 0,
+					moved: 0
+				});
+				this.ask(kept);
+				return;
+			case "verifying":
+				this.show(kept, {
+					state: "transferring",
+					stage: "verifying",
+					transferred,
+					size,
+					direction: "in"
+				});
+				return;
+			default: this.show(kept, {
+				state: "transferring",
+				transferred,
+				size,
+				direction: "in"
+			});
+		}
+	}
+	add(kept) {
+		this.kept.set(kept.id, kept);
+		this.byMessage.set(`${kept.groupId}\n${kept.message}`, kept.id);
+	}
+	/** Bytes this device fetched by itself from the group and keeps (or is fetching): what `autoBytesPerGroup` bounds. */
+	keptAutomatically(groupId) {
+		let sum = 0;
+		for (const kept of this.kept.values()) if (kept.groupId === groupId && kept.auto && !kept.mine) sum += kept.meta.size;
+		return sum;
+	}
+	groupField(kept) {
+		return {
+			message: kept.message,
+			author: kept.author,
+			...kept.auto && { auto: true },
+			...kept.asked && { asked: true }
+		};
+	}
+	pace(windows, key, limit, ms) {
+		let window = windows.get(key);
+		if (!window) windows.set(key, window = new RateWindow(limit, ms, () => this.deps.now()));
+		return window;
+	}
+	show(kept, view) {
+		this.deps.transfers.set(kept.id, view);
+		this.deps.changed();
+	}
+};
+function messageFile(kept) {
+	const { name, size, mime, voice, video, image } = kept.meta;
+	return {
+		id: kept.id,
+		name,
+		size,
+		mime,
+		...voice && { voice },
+		...video && { video },
+		...image && { image }
+	};
+}
+//#endregion
 //#region src/typing.ts
 /**
 * `typing --for` and `group typing --for`: a `start` holds 6 s on the other side (WISP 401 § Typing, WISP 902 · Group
@@ -1433,6 +2160,9 @@ function decodeWithFfmpeg(path, command = process.env.GHOSTLY_FFMPEG || "ffmpeg"
 * Files and voice notes in a chat (WISP 1100, phase 3), as the app's composer sends them (packages/browser
 * platform/services.ts `sendFile`): the bytes go into the profile's file store first, then the engine offers them.
 * Large files follow files/3: the receiving side's person (here, a command) accepts or declines each offer.
+*
+* In a group (WISP 503 · Group Files) the file is announced as a group message, and each member's app fetches the
+* bytes from whoever holds them: by itself up to the automatic limits, on `file accept` past them.
 */
 var TYPES$1 = {
 	".png": "image/png",
@@ -1476,16 +2206,143 @@ function filesOf(messages, transfers) {
 	}));
 }
 /**
-* The chat a file belongs to: a file id starts with its chat's id, so the chat may be left out; given, it must be
-* the file's own.
+* The chat a file command names, or else a group (`group:<id>`, or a group's id, prefix or name where no chat has it),
+* as `forward` reads them. A name that is neither says what a chat would.
+*/
+function chatOrGroupOf(ctx, params) {
+	const ref = str(params, "chat", true);
+	if (ref.startsWith("group:")) return { group: findGroup(state(ctx).groups, ref.slice(6)) };
+	try {
+		return { link: chatOf(ctx, params) };
+	} catch (error) {
+		if (!(error instanceof CliError) || error.code !== "not_found") throw error;
+		try {
+			return { group: findGroup(state(ctx).groups, ref) };
+		} catch {
+			throw error;
+		}
+	}
+}
+/**
+* The chat or group a file belongs to: a file id starts with its chat's id (a group's file with `group-<id>-`), so it
+* may be left out; given, it must be the file's own. `where` is what the answer names it by.
 */
 function fileChat(ctx, params, fileId) {
+	const groupId = groupOfFile(fileId, state(ctx).groups.map((g) => g.id));
+	if (groupId) {
+		const named = params.chat === void 0 ? void 0 : chatOrGroupOf(ctx, params);
+		if (named && !("group" in named && named.group.id === groupId)) throw new CliError("not_found", `No file ${fileId} in this ${"group" in named ? "group" : "chat"}`);
+		return {
+			linkId: `group:${groupId}`,
+			where: { group: groupId }
+		};
+	}
 	const link = params.chat === void 0 ? state(ctx).links.find((l) => fileId.startsWith(`${l.id}-in-`) || fileId.startsWith(`${l.id}-out-`)) : chatOf(ctx, params);
 	if (!link) throw new CliError("not_found", `No file ${fileId}`);
 	if (!fileId.startsWith(`${link.id}-`)) throw new CliError("not_found", `No file ${fileId} in this chat`);
-	return link;
+	return {
+		linkId: link.id,
+		where: { chat: link.id }
+	};
 }
 var VOICE_ONLY = "A voice note is audio (webm, ogg, mp4, mpeg, aac, m4a or wav) of at most 15 minutes, with peaks from 0 to 255";
+/** `--voice [ms] [--peaks …]`: the voice description, its length and waveform measured from the sound when not given. */
+async function voiceOf(params, path, mime) {
+	if (params.voice === void 0) return {};
+	if (!PLAYABLE_AUDIO.test(baseMime(mime))) throw new CliError("bad_request", VOICE_ONLY);
+	let duration = params.voice === true ? void 0 : num(params, "voice", 0, { min: 1 });
+	let peaks = list(params, "peaks").map(Number);
+	let warning;
+	if (duration === void 0 || !peaks.length) {
+		const measured = await measureVoice(path);
+		if ("voice" in measured) {
+			duration ??= measured.voice.duration;
+			if (!peaks.length) peaks = measured.voice.peaks;
+		} else if (duration === void 0) throw new CliError("bad_request", `Could not measure the voice note (${measured.problem}): give its length as --voice <ms>`);
+		else warning = `Sent without a waveform: could not read the sound (${measured.problem})`;
+	}
+	const voice = parseVoiceMeta({
+		duration,
+		peaks: peaks.length ? peaks : new Array(VOICE_LIMITS.bars).fill(0)
+	}, mime);
+	if (!voice) throw new CliError("bad_request", VOICE_ONLY);
+	return {
+		voice,
+		...warning ? { warning } : {}
+	};
+}
+/**
+* A file announced in a group (WISP 503): its bytes staged under a group file id with their digest, as a chat's are, then
+* the announcement. This device is its first holder and serves the members who ask.
+*/
+async function sendToGroup(ctx, params, group, path, size) {
+	if (size > GROUP_FILE_LIMITS.maxBytes) throw new CliError("refused", `Too large for a group (at most ${GROUP_FILE_LIMITS.maxBytes} bytes)`);
+	if (!size) throw new CliError("refused", "An empty file cannot go to a group");
+	const mime = mimeOf(path, str(params, "mime"));
+	const replyTo = str(params, "reply");
+	if (replyTo) {
+		if (!(await node(ctx).groupMessages({ groupId: group.id })).some((m) => m.id === replyTo || replyRef(m) === replyTo)) throw new CliError("not_found", "That message is not in this group, or cannot be replied to");
+	}
+	const { voice, warning } = await voiceOf(params, path, mime);
+	const source = await openAsBlob(path, { type: mime });
+	const image = voice ? void 0 : await readImageMeta(source, mime);
+	const fileId = groupFileId(group.id, "out");
+	const file = {
+		id: fileId,
+		name: sanitizeFileName(str(params, "name") ?? basename(path)),
+		size,
+		mime,
+		...voice ? { voice } : {},
+		...image ? { image } : {}
+	};
+	const timestamp = Date.now();
+	const bytes = await fileBytes();
+	const digest = await bytes.stage(fileId, source);
+	await fileStore.put({
+		id: fileId,
+		linkId: `group:${group.id}`,
+		bytes: bytes.kind,
+		digest,
+		createdAt: timestamp,
+		direction: "out",
+		metadata: {
+			name: file.name,
+			size,
+			mime,
+			timestamp,
+			...voice ? { voice } : {},
+			...image ? { image } : {}
+		},
+		transfer: {
+			state: "transferring",
+			transferred: 0,
+			size
+		}
+	});
+	endTyping(ctx, { groupId: group.id }, false);
+	const result = await node(ctx).sendGroupFile({
+		groupId: group.id,
+		file,
+		...replyTo ? { replyTo } : {}
+	});
+	if (result.error) {
+		await removeStored(fileId).catch(() => {});
+		throw result.refused ? new CliError("refused", result.error) : groupSendRefused(result.error);
+	}
+	return {
+		group: group.id,
+		messageId: result.messageId ?? null,
+		file: {
+			id: fileId,
+			name: file.name,
+			size,
+			mime,
+			...voice ? { voice: true } : {},
+			...image ? { image } : {}
+		},
+		...warning ? { warning } : {}
+	};
+}
 var ACTIONS = [
 	"accept",
 	"decline",
@@ -1497,7 +2354,7 @@ var ACTIONS = [
 ];
 var FILE_METHODS = {
 	async "file.send"(ctx, params) {
-		const link = chatOf(ctx, params);
+		const target = chatOrGroupOf(ctx, params);
 		const path = resolve(str(params, "path", true));
 		let info;
 		try {
@@ -1506,6 +2363,8 @@ var FILE_METHODS = {
 			throw new CliError("not_found", `No file ${path}`);
 		}
 		if (!info.isFile()) throw new CliError("bad_request", `${path} is not a file`);
+		if ("group" in target) return sendToGroup(ctx, params, target.group, path, info.size);
+		const { link } = target;
 		if (link.profile && link.dataLink === "open" && !link.capabilities?.files) throw new CliError("unavailable", "The contact's app takes no files");
 		if (!link.capabilities?.largeFiles && info.size > LIMITS.maxFileBytes) throw new CliError("refused", `Too large for the contact's app (at most ${LIMITS.maxFileBytes} bytes)`);
 		if (typeof link.peerFileRoom === "number" && info.size > link.peerFileRoom) throw new CliError("refused", `Not enough space on the contact's device (${link.peerFileRoom} bytes free)`);
@@ -1514,25 +2373,7 @@ var FILE_METHODS = {
 		if (replyTo) {
 			if (!(await node(ctx).getMessages(link.id)).some((m) => m.id === replyTo || replyRef(m) === replyTo)) throw new CliError("not_found", "That message is not in this chat, or cannot be replied to");
 		}
-		let voice, warning;
-		if (params.voice !== void 0) {
-			if (!PLAYABLE_AUDIO.test(baseMime(mime))) throw new CliError("bad_request", VOICE_ONLY);
-			let duration = params.voice === true ? void 0 : num(params, "voice", 0, { min: 1 });
-			let peaks = list(params, "peaks").map(Number);
-			if (duration === void 0 || !peaks.length) {
-				const measured = await measureVoice(path);
-				if ("voice" in measured) {
-					duration ??= measured.voice.duration;
-					if (!peaks.length) peaks = measured.voice.peaks;
-				} else if (duration === void 0) throw new CliError("bad_request", `Could not measure the voice note (${measured.problem}): give its length as --voice <ms>`);
-				else warning = `Sent without a waveform: could not read the sound (${measured.problem})`;
-			}
-			voice = parseVoiceMeta({
-				duration,
-				peaks: peaks.length ? peaks : new Array(VOICE_LIMITS.bars).fill(0)
-			}, mime);
-			if (!voice) throw new CliError("bad_request", VOICE_ONLY);
-		}
+		const { voice, warning } = await voiceOf(params, path, mime);
 		const source = await openAsBlob(path, { type: mime });
 		const image = voice ? void 0 : await readImageMeta(source, mime);
 		const wireId = toBase64Url$1(randomBytes$1(12));
@@ -1595,34 +2436,58 @@ var FILE_METHODS = {
 		};
 	},
 	async "file.list"(ctx, params) {
-		const link = chatOf(ctx, params);
+		const target = chatOrGroupOf(ctx, params);
+		if ("group" in target) return {
+			group: target.group.id,
+			files: filesOf(await node(ctx).groupMessages({ groupId: target.group.id }), state(ctx).transfers)
+		};
 		return {
-			chat: link.id,
-			files: filesOf(await node(ctx).getMessages(link.id), state(ctx).transfers)
+			chat: target.link.id,
+			files: filesOf(await node(ctx).getMessages(target.link.id), state(ctx).transfers)
 		};
 	},
 	/**
 	* files/3: answer an offer, or pause, resume or cancel a transfer, either way; `resend` a file sent from here that
 	* stopped moving (or failed), `request` again one that stopped arriving. Without a chat, the file's id names it.
+	* A group's file (WISP 503) takes `accept` (download one this device did not fetch by itself) and `request`.
 	*/
 	async "file.action"(ctx, params) {
 		const fileId = str(params, "file", true);
-		const link = fileChat(ctx, params, fileId);
+		const { linkId, where } = fileChat(ctx, params, fileId);
 		const action = oneOf(params, "action", ACTIONS, "accept");
+		if ("group" in where) {
+			if (action !== "accept" && action !== "request") throw new CliError("bad_request", "A group's file is downloaded (file accept) or asked for again (file request)");
+			if (state(ctx).transfers[fileId]?.state === "done") throw new CliError("refused", "Nothing to ask for: the file is all here");
+			try {
+				await node(ctx).fileAction({
+					linkId,
+					fileId,
+					action
+				});
+			} catch (error) {
+				throw new CliError("refused", error instanceof Error ? error.message : String(error));
+			}
+			return {
+				...where,
+				file: fileId,
+				action,
+				transfer: state(ctx).transfers[fileId] ?? null
+			};
+		}
 		if (action === "resend" || action === "request") {
-			const outgoing = fileId.startsWith(`${link.id}-out-`);
+			const outgoing = fileId.startsWith(`${linkId}-out-`);
 			if (outgoing !== (action === "resend")) throw new CliError("bad_request", outgoing ? "A file sent from here is sent again: file resend" : "A received file is asked for again: file request");
 			const transfer = state(ctx).transfers[fileId];
 			if (!transfer || transfer.state === "done") throw new CliError("refused", outgoing ? "Nothing to send again: it arrived whole" : "Nothing to ask for: the file is all here");
 			if (transfer.state === "failed" && (!outgoing || !transfer.retry)) throw new CliError("refused", `It ended: ${transfer.error ?? "failed"}`);
 		}
 		await node(ctx).fileAction({
-			linkId: link.id,
+			linkId,
 			fileId,
 			action
 		});
 		return {
-			chat: link.id,
+			...where,
 			file: fileId,
 			action,
 			transfer: state(ctx).transfers[fileId] ?? null
@@ -1634,7 +2499,7 @@ var FILE_METHODS = {
 	*/
 	async "file.wait"(ctx, params) {
 		const fileId = str(params, "file", true);
-		const link = fileChat(ctx, params, fileId);
+		const { where } = fileChat(ctx, params, fileId);
 		const stored = await fileStore.get(fileId);
 		if (!stored && !state(ctx).transfers[fileId]) throw new CliError("not_found", `No file ${fileId}`);
 		const transfer = await waitForState(ctx, (s) => {
@@ -1655,11 +2520,11 @@ var FILE_METHODS = {
 		});
 		if (transfer.state === "failed") throw new CliError("engine", transfer.error ?? "The transfer failed", {
 			file: fileId,
-			chat: link.id,
+			...where,
 			retry: !!transfer.retry
 		});
 		return {
-			chat: link.id,
+			...where,
 			file: fileId,
 			state: "done",
 			size: transfer.size
@@ -1911,7 +2776,7 @@ async function sendCard(ctx, params, kind) {
 			status: "running",
 			startedAt: now,
 			updatedAt: now
-		} : { state: "active" },
+		} : kind === "routine" ? { state: "active" } : {},
 		...fields,
 		kind,
 		id
@@ -2034,6 +2899,82 @@ async function flushCardUpdates(ctx) {
 	for (const pace of waiting) pace.flush();
 	await Promise.all(waiting.map((pace) => pace.flushed));
 }
+/** A usage card's fields: all of them are said again by each report, so one not given goes from the card. */
+var USAGE_FIELDS = [
+	"left",
+	"used",
+	"limit",
+	"label",
+	"account",
+	"window",
+	"resetsAt",
+	"updatedAt",
+	"windows"
+];
+/** The id a bot's usage card goes by when it names none: one live card per chat. */
+var USAGE_CARD_ID = "usage";
+/**
+* One chat's usage report (WISP 405 § Usage): the bot's usage card there, kept as one message. The first report sends
+* it; every later one edits it in place (quiet: no sound, no unread, no move in the list), paced as a task's updates.
+* A report is whole: what it does not say goes from the card. A card at its edits' cap gives way to a new message.
+*/
+async function reportUsage(ctx, ref, fields, params) {
+	const target = chatOrGroup(ctx, ref);
+	const id = typeof fields.id === "string" && fields.id ? fields.id : USAGE_CARD_ID;
+	const report = {
+		updatedAt: Date.now(),
+		...fields,
+		kind: "usage",
+		id
+	};
+	checked$1(report);
+	const sent = await cardMessage(ctx, target, "usage", id).catch(() => void 0);
+	const wait = oneOf(params, "wait", ["none", "sent"], "none");
+	if (!sent || (sent.edit?.seq ?? 0) >= STATUS_CARD_LIMITS.edits) return {
+		...await sendCard(ctx, {
+			...params,
+			chat: ref,
+			card: report,
+			wait
+		}, "usage"),
+		updated: false
+	};
+	const patch = {};
+	for (const key of USAGE_FIELDS) patch[key] = report[key] ?? null;
+	return {
+		...await updateCard(ctx, {
+			...params,
+			chat: ref,
+			usage: id,
+			card: patch,
+			wait: wait === "none" ? "none" : target.group ? "sent" : "confirmed"
+		}, "usage"),
+		updated: true
+	};
+}
+/** `usage send`: one chat or group, or (`all`) every 1:1 chat with a contact; a chat that refuses is said, not fatal. */
+async function sendUsage(ctx, params) {
+	const fields = fieldsOf(params);
+	if (!bool(params, "all")) return reportUsage(ctx, str(params, "chat", true), fields, params);
+	if (str(params, "chat")) throw new CliError("bad_request", "Name a chat or --all, not both");
+	checked$1({
+		updatedAt: Date.now(),
+		...fields,
+		kind: "usage",
+		id: typeof fields.id === "string" && fields.id ? fields.id : USAGE_CARD_ID
+	});
+	const chats = state(ctx).links.filter((link) => link.profile && link.peerPubKeyZ32);
+	const results = [];
+	for (const link of chats) try {
+		results.push(await reportUsage(ctx, link.id, fields, params));
+	} catch (error) {
+		results.push({
+			chat: link.id,
+			error: error instanceof Error ? error.message : String(error)
+		});
+	}
+	return { chats: results };
+}
 var STATUS_CARD_METHODS = {
 	/** WISP 405 · Status Cards: a task card in a chat or a group; the answer names the task's id and its message. */
 	"task.send": (ctx, params) => sendCard(ctx, params, "task"),
@@ -2042,7 +2983,9 @@ var STATUS_CARD_METHODS = {
 	/** A routine card (its schedule, state, runs); `run` records one. */
 	"routine.send": (ctx, params) => sendCard(ctx, params, "routine"),
 	/** A routine's update, as a task's; `run` records a run as its last and the newest of its recent ones. */
-	"routine.update": (ctx, params) => updateCard(ctx, params, "routine")
+	"routine.update": (ctx, params) => updateCard(ctx, params, "routine"),
+	/** WISP 405 § Usage: how much of a quota the bot has left, kept as one card per chat; `all` for every 1:1 chat. */
+	"usage.send": sendUsage
 };
 //#endregion
 //#region src/buttons.ts
@@ -6248,7 +7191,7 @@ function openPassportWindow(url) {
 	return window.open(url, "pubky-passport", "popup,width=520,height=760");
 }
 /** A 401 or 403 from the homeserver: the session it was given is not one it accepts. */
-var refused = (e) => {
+var refused$1 = (e) => {
 	const status = e?.data?.statusCode;
 	return status === 401 || status === 403;
 };
@@ -6479,7 +7422,7 @@ async function approveAndWork(options, work, { grant, cookie, opened, settled, c
 		throw e;
 	}
 	const fail = (what) => (e) => {
-		if (viaCookie && !cookieKept && refused(e)) throw new Error("Pubky Ring approved, but this browser blocks your homeserver's sign-in cookie (Vanadium and Safari block cookies from other sites), so nothing was written. Approve with Pubky Passport instead, or use Firefox or the Ghostly desktop app.");
+		if (viaCookie && !cookieKept && refused$1(e)) throw new Error("Pubky Ring approved, but this browser blocks your homeserver's sign-in cookie (Vanadium and Safari block cookies from other sites), so nothing was written. Approve with Pubky Passport instead, or use Firefox or the Ghostly desktop app.");
 		throw failure(what, e);
 	};
 	const approved = session;
@@ -8489,7 +9432,7 @@ async function restoreProfile(home, name, file, passphrase) {
 		if (!reader) {
 			const payload = await readWhole(file, passphrase ?? "");
 			work = await restoringFolder(home, name);
-			await writeWhole(work, payload);
+			await writeWhole$1(work, payload);
 			return await finishRestore(home, name, work);
 		}
 		const next = async () => {
@@ -8582,7 +9525,7 @@ async function readWhole(file, passphrase) {
 	if (payload?.format !== FORMAT_1 || typeof payload.store !== "string" || !Array.isArray(payload.files)) throw new CliError("refused", "This backup is not a headless Ghostly profile");
 	return payload;
 }
-async function writeWhole(paths, payload) {
+async function writeWhole$1(paths, payload) {
 	await mkdir(paths.db, {
 		recursive: true,
 		mode: 448
@@ -12206,6 +13149,565 @@ function connectDaemon(path, timeoutMs = 2e3) {
 	});
 }
 //#endregion
+//#region src/apps.ts
+var APP_SOURCE = "ghostly-app.json";
+var APP_REVOKE_FILE = "ghostly-revoke.json";
+var STORE_INDEX_FILE = "ghostly-store.json";
+var STORE_SIG_FILE = "ghostly-store.sig";
+/** How long `app verify` waits for a URL, and how many redirects it follows (each checked as the first). */
+var FETCH_TIMEOUT_MS = 6e4;
+var MAX_REDIRECTS = 5;
+var KEY_HEADER = {
+	publisher: "Ghostly publisher key (WISP 1200). Secret: never share or commit it. Back it up: an app signed with it is updated only with it.",
+	store: "Ghostly store key (WISP 1200). Secret: keep it offline, never share or commit it. Back it up: a store is its key."
+};
+var PEM = /-----BEGIN PRIVATE KEY-----\r?\n([A-Za-z0-9+/=\r\n]+)-----END PRIVATE KEY-----/;
+/** Refuses a key file that is not a plain file of this user's, or that anyone else may read or write. */
+function checkKeyFile(path) {
+	const info = statSync(path);
+	if (!info.isFile()) throw new CliError("bad_request", `${path} is not a file: --key names a key file`);
+	if (process.platform === "win32") return;
+	if (process.getuid && info.uid !== process.getuid()) throw new CliError("refused", `${path} is not this user's: a key file must be yours alone`);
+	if ((info.mode & 63) !== 0) throw new CliError("refused", `${path} may be read by others (mode ${(info.mode & 511).toString(8)}): run chmod 600 ${path}, and think whether the key was seen`);
+}
+/** Reads a key file: the PEM block, an Ed25519 key, and the kind its first line names (when it names one). */
+function readKey(path, kind) {
+	checkKeyFile(path);
+	const text = readFileSync(path, "utf8");
+	const other = kind === "publisher" ? "store" : "publisher";
+	if (text.startsWith(`Ghostly ${other} key`)) throw new CliError("refused", `${path} is a ${other} key: ${kind === "publisher" ? "a store key never signs an app" : "a publisher key never signs a store index"} (WISP 1200 · Stores)`);
+	const block = PEM.exec(text);
+	let seed;
+	if (block) try {
+		const key = createPrivateKey(block[0]);
+		const d = key.asymmetricKeyType === "ed25519" ? key.export({ format: "jwk" }).d : void 0;
+		if (d) seed = fromBase64Url$1(d);
+	} catch {}
+	if (!seed || seed.length !== 32) throw new CliError("bad_request", `${path} holds no Ed25519 private key (a PEM "PRIVATE KEY" block, as openssl genpkey -algorithm ed25519 writes)`);
+	const signer = seedSigner(seed);
+	return {
+		signer,
+		key: toZ32(signer.publicKey),
+		created: false
+	};
+}
+/** Makes a key file: owner-only from the start, never over a file that is there. */
+function makeKey(path, kind) {
+	mkdirSync(dirname(path), {
+		recursive: true,
+		mode: 448
+	});
+	const { privateKey } = generateKeyPairSync("ed25519");
+	const pem = privateKey.export({
+		type: "pkcs8",
+		format: "pem"
+	});
+	const fd = openSync(path, "wx", 384);
+	try {
+		writeSync(fd, `${KEY_HEADER[kind]}\n${pem}`);
+	} finally {
+		closeSync(fd);
+	}
+	return {
+		...readKey(path, kind),
+		created: true
+	};
+}
+/** What the person is told on stderr when a key was made: where, which, and to back it up. Never the key. */
+function madeKeyNote(path, kind, key) {
+	return kind === "publisher" ? `new publisher key written to ${path}; back it up (${appFingerprint(key)}: an app is updated only with the key that signed it, and phase 1 has no recovery)` : `new store key written to ${path}; back it up and keep it offline (${appFingerprint(key)}: a store is its key)`;
+}
+var refused = (what, reading, extra = {}) => new CliError("refused", `${what} (${reading.reason}${reading.detail ? `: ${reading.detail}` : ""})`, {
+	reason: reading.reason,
+	...reading.detail ? { detail: reading.detail } : {},
+	...extra
+});
+/** A bundle file's bytes: its size is checked before it is read, so a huge file is refused unread. */
+function readBundleFile(path) {
+	const info = statSync(path);
+	if (info.isDirectory()) throw new CliError("bad_request", `${path} is a folder: name a .ghostlyapp file`);
+	if (info.size > APP_BUNDLE_LIMITS.bundleBytes) throw refused(`${path} is not a valid bundle`, {
+		reason: "too-large",
+		detail: `${info.size} bytes`
+	});
+	return new Uint8Array(readFileSync(path));
+}
+/**
+* A bundle at an https URL, as a client fetches one: `https:` only, no user or password, jsDelivr only at a full
+* commit (WISP 1200 · Manifest, "Every URL"); every redirect is held to the same rule, and the download stops past
+* 16 MiB.
+*/
+async function fetchBundle(url) {
+	let at = url;
+	for (let hop = 0;; hop++) {
+		if (!isAppUrl(at)) throw new CliError(hop ? "refused" : "usage", hop ? `${url} redirects to ${at}, which a client does not read (https only, no user or password, jsDelivr only at a full commit)` : `Not a URL a client reads: https only, at most ${APP_BUNDLE_LIMITS.url} characters, no user or password, and jsDelivr only as https://cdn.jsdelivr.net/gh/<owner>/<repo>@<40-hex commit>/<path>`);
+		let response;
+		try {
+			response = await fetch(at, {
+				redirect: "manual",
+				signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+			});
+		} catch (error) {
+			if (error instanceof Error && error.name === "TimeoutError") throw new CliError("timeout", `${at} did not answer in ${FETCH_TIMEOUT_MS / 1e3} s`);
+			throw new CliError("unavailable", `Could not read ${at}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		if (response.status >= 300 && response.status < 400 && response.headers.get("location")) {
+			await response.body?.cancel();
+			if (hop >= MAX_REDIRECTS) throw new CliError("refused", `${url} redirects more than ${MAX_REDIRECTS} times`);
+			at = new URL(response.headers.get("location"), at).href;
+			continue;
+		}
+		if (response.status === 404 || response.status === 410) {
+			await response.body?.cancel();
+			throw new CliError("not_found", `${at} answered ${response.status}`);
+		}
+		if (!response.ok || !response.body) {
+			await response.body?.cancel();
+			throw new CliError("unavailable", `${at} answered ${response.status}`);
+		}
+		const limit = APP_BUNDLE_LIMITS.bundleBytes;
+		const tooLarge = (bytes) => refused(`${url} is not a valid bundle`, {
+			reason: "too-large",
+			detail: `${bytes} bytes`
+		});
+		const length = Number(response.headers.get("content-length"));
+		if (Number.isFinite(length) && length > limit) {
+			await response.body.cancel();
+			throw tooLarge(length);
+		}
+		const chunks = [];
+		let total = 0;
+		const reader = response.body.getReader();
+		try {
+			for (;;) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				total += value.length;
+				if (total > limit) {
+					await reader.cancel();
+					throw tooLarge(`more than ${limit}`);
+				}
+				chunks.push(value);
+			}
+		} catch (error) {
+			if (error instanceof CliError) throw error;
+			if (error instanceof Error && error.name === "TimeoutError") throw new CliError("timeout", `${at} did not finish in ${FETCH_TIMEOUT_MS / 1e3} s`);
+			throw new CliError("unavailable", `Could not read ${at}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		const out = new Uint8Array(total);
+		let offset = 0;
+		for (const chunk of chunks) {
+			out.set(chunk, offset);
+			offset += chunk.length;
+		}
+		return out;
+	}
+}
+/** What a checked bundle is, as `app verify` and `app publish` print it. */
+function described(bundle, bytes) {
+	const m = bundle.manifest;
+	return {
+		ref: appRef(m.publisher, m.name),
+		publisher: m.publisher,
+		fingerprint: appFingerprint(m.publisher),
+		name: m.name,
+		title: m.title,
+		version: m.version,
+		sequence: m.sequence,
+		digest: bundle.digest,
+		bytes: bytes.length,
+		sha256: toBase64Url$1(createHash("sha256").update(bytes).digest())
+	};
+}
+/** `app verify <bundle|url>`: every check a client makes before it stores a bundle (WISP 1200 · Reading a bundle). */
+async function verifyApp(source) {
+	const bytes = /^[a-z][a-z0-9+.-]*:\/\//i.test(source) ? await fetchBundle(source) : readBundleFile(resolve(source));
+	const read = readAppBundle(bytes);
+	if (!read.ok) throw refused(`${source} is not a valid bundle`, read);
+	return {
+		valid: true,
+		...described(read.bundle, bytes),
+		manifest: read.bundle.manifest
+	};
+}
+/** Every file of the folder, as the bundle names it; dot files and folders are left out and listed. */
+function collectFiles(dir, leaveOut) {
+	const files = [];
+	const skipped = [];
+	let bytes = 0;
+	const walk = (folder) => {
+		for (const name of readdirSync(folder).sort()) {
+			const full = join(folder, name);
+			const path = relative(dir, full).split(sep).join("/");
+			if (leaveOut.has(full)) continue;
+			if (name.startsWith(".")) {
+				skipped.push(path);
+				continue;
+			}
+			const info = lstatSync(full);
+			if (info.isSymbolicLink()) throw new CliError("bad_request", `${path} is a link: a bundle holds the folder's own files (copy it in, or remove it)`);
+			if (info.isDirectory()) {
+				walk(full);
+				continue;
+			}
+			if (!info.isFile()) throw new CliError("bad_request", `${path} is not a file`);
+			files.push({
+				path,
+				full,
+				size: info.size
+			});
+			bytes += info.size;
+			if (files.length > APP_BUNDLE_LIMITS.files) throw refused(`${dir} holds more files than a bundle may`, {
+				reason: "too-many-files",
+				detail: `more than ${APP_BUNDLE_LIMITS.files}`
+			});
+			if (bytes > APP_BUNDLE_LIMITS.bundleBytes) throw refused(`${dir} holds more than a bundle may`, {
+				reason: "too-large",
+				detail: `more than ${APP_BUNDLE_LIMITS.bundleBytes} bytes of files`
+			});
+		}
+	};
+	walk(dir);
+	return {
+		files,
+		skipped
+	};
+}
+/** Fields of `ghostly-app.json` the command writes itself. */
+var WRITTEN = ["publisher", "files"];
+function readSource(path) {
+	if (!existsSync(path)) throw new CliError("not_found", `No ${APP_SOURCE} in ${dirname(path)}: it holds the manifest's fields (name, version, title, tagline, entry, permissions, runtime, license, ...) but publisher, sequence and files, which publish writes`);
+	let value;
+	try {
+		value = JSON.parse(readFileSync(path, "utf8"));
+	} catch (error) {
+		throw new CliError("bad_request", `${path} is not JSON: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new CliError("bad_request", `${path} is not a JSON object`);
+	const draft = value;
+	const written = WRITTEN.filter((k) => k in draft);
+	if (written.length) throw new CliError("bad_request", `${path} has ${written.join(" and ")}: publish writes ${written.length > 1 ? "them" : "it"} from the key and the folder's files`);
+	if (draft.ghostlyApp !== void 0 && draft.ghostlyApp !== 1) throw refused(`${path} is not a manifest this release makes`, {
+		reason: "unsupported-format",
+		detail: "ghostlyApp is not 1"
+	});
+	if (draft.sequence !== void 0 && !(Number.isSafeInteger(draft.sequence) && draft.sequence >= 1)) throw new CliError("bad_request", `${path}: sequence is a whole number from 1 (or leave it out: publish raises it by itself)`);
+	return draft;
+}
+/** Writes a file whole or not at all: a reader never sees half a bundle (and a dot file left by a crash is never bundled). */
+function writeWhole(path, bytes) {
+	const tmp = join(dirname(path), `.${basename(path)}.${process.pid}.tmp`);
+	writeFileSync(tmp, bytes);
+	renameSync(tmp, path);
+}
+/**
+* `app publish <dir> --key <file> [--out <file>]`: `<dir>/ghostly-app.json` (the manifest without `publisher`,
+* `sequence` and `files`) and every other file in `<dir>` become one signed bundle, by default `<dir>/app.ghostlyapp`.
+* The sequence is `--sequence` (higher than the bundle already at `--out`'s), else one more than that bundle's (or
+* the source's `sequence`, if higher, else 1). The
+* key file is made when it is missing and no earlier bundle is there to update.
+*/
+async function publishApp(dirArg, keyArg, outArg, sequenceArg) {
+	if (sequenceArg !== void 0 && !(Number.isSafeInteger(sequenceArg) && sequenceArg >= 1)) throw new CliError("usage", `--sequence takes a whole number from 1, not ${sequenceArg}`);
+	const dir = resolve(dirArg);
+	if (!statSync(dir).isDirectory()) throw new CliError("bad_request", `${dir} is not a folder`);
+	const keyPath = resolve(keyArg);
+	const out = resolve(outArg ?? join(dir, "app.ghostlyapp"));
+	const sourcePath = join(dir, APP_SOURCE);
+	const draft = readSource(sourcePath);
+	let previous = null;
+	if (existsSync(out)) {
+		const read = readAppBundle(readBundleFile(out));
+		if (!read.ok) throw refused(`${out} is there and is not a valid bundle: move it away, or name another --out`, read);
+		previous = read.bundle.manifest;
+	}
+	let key;
+	if (existsSync(keyPath)) key = readKey(keyPath, "publisher");
+	else if (previous) throw new CliError("not_found", `No key file ${keyPath}: ${out} is signed by ${appFingerprint(previous.publisher)}, and only that key publishes its next version`);
+	else key = makeKey(keyPath, "publisher");
+	if (previous && previous.publisher !== key.key) throw refused(`${out} is ${appRef(previous.publisher, previous.name)}, signed by another key (${appFingerprint(previous.publisher)}): a version of an app is signed by its own key`, { reason: "other-app" }, { publisher: previous.publisher });
+	if (previous && previous.name !== draft.name) throw refused(`${out} is the app ${JSON.stringify(previous.name)}, not ${JSON.stringify(draft.name)}: name another --out for another app`, { reason: "other-app" });
+	if (sequenceArg !== void 0 && previous && sequenceArg <= previous.sequence) throw refused(`--sequence ${sequenceArg} is not higher than the ${previous.sequence} of ${out}: every client refuses a lower one, and the same one with other content is equivocation`, { reason: sequenceArg < previous.sequence ? "rollback" : "equivocation" }, { previous: previous.sequence });
+	const sequence = sequenceArg ?? Math.max(previous ? previous.sequence + 1 : 1, draft.sequence ?? 1);
+	const { files, skipped } = collectFiles(dir, /* @__PURE__ */ new Set([
+		sourcePath,
+		out,
+		join(dir, APP_REVOKE_FILE)
+	]));
+	const contents = files.map((f) => ({
+		path: f.path,
+		bytes: new Uint8Array(readFileSync(f.full))
+	}));
+	const manifest = {
+		...draft,
+		ghostlyApp: 1,
+		publisher: key.key,
+		sequence,
+		files: contents.map((f) => ({
+			path: f.path,
+			size: f.bytes.length,
+			sha256: toBase64Url$1(createHash("sha256").update(f.bytes).digest())
+		}))
+	};
+	const checked = checkAppManifest(JSON.parse(JSON.stringify(manifest)));
+	if (!checked.ok) throw refused(`${sourcePath} and the folder's files make no valid manifest`, checked);
+	const { bytes: manifestBytes, signature } = await signAppObject(APP_PREFIXES.app, checked.manifest, key.signer);
+	const bundle = assembleAppBundle(manifestBytes, canonicalJsonBytes(signature), contents.map((f) => f.bytes));
+	const read = readAppBundle(bundle);
+	if (!read.ok) throw refused("The bundle made is not valid", read);
+	mkdirSync(dirname(out), { recursive: true });
+	writeWhole(out, bundle);
+	return {
+		...described(read.bundle, bundle),
+		previous: previous?.sequence ?? null,
+		out,
+		files: contents.map((f) => f.path),
+		...skipped.length ? { skipped } : {},
+		keyCreated: key.created,
+		...key.created ? { warning: madeKeyNote(keyPath, "publisher", key.key) } : {}
+	};
+}
+/**
+* `app revoke <dir> --key <file> (--digest <digest>... | --up-to <sequence>) [--reason <text>] [--bundle <file>]`: a
+* `ghostly-revoke/1` statement (WISP 1200 · Publisher keys, Revocation) for the app whose bundle is `<dir>/app.ghostlyapp`
+* (or `--bundle`), signed by that app's publisher key and added to `<dir>/ghostly-revoke.json`, which stays canonical.
+* The key is never made here: only the key that signed the app may revoke its versions.
+*/
+async function revokeApp(dirArg, keyArg, what) {
+	const dir = resolve(dirArg);
+	const bundlePath = resolve(what.bundle ?? join(dir, "app.ghostlyapp"));
+	const listPath = join(dir, APP_REVOKE_FILE);
+	const usage = "ghostly app revoke <dir> --key <file> (--digest <digest>... | --up-to <sequence>) [--reason <text>]";
+	const digests = what.digests ?? [];
+	if (digests.length > 0 === (what.upTo !== void 0)) throw new CliError("usage", `Give --digest (again for each) or --up-to, one of the two: ${usage}`);
+	if (what.upTo !== void 0 && !(Number.isSafeInteger(what.upTo) && what.upTo >= 1)) throw new CliError("usage", `--up-to takes a sequence, a whole number from 1, not ${what.upTo}`);
+	if (!existsSync(bundlePath)) throw new CliError("not_found", `No bundle ${bundlePath}: a revocation names the app of the bundle in <dir> (or --bundle)`);
+	const read = readAppBundle(readBundleFile(bundlePath));
+	if (!read.ok) throw refused(`${bundlePath} is not a valid bundle`, read);
+	const manifest = read.bundle.manifest;
+	const ref = appRef(manifest.publisher, manifest.name);
+	const keyPath = resolve(keyArg);
+	if (!existsSync(keyPath)) throw new CliError("not_found", `No key file ${keyPath}: only the key that signed ${ref} (${appFingerprint(manifest.publisher)}) revokes its versions`);
+	const key = readKey(keyPath, "publisher");
+	if (key.key !== manifest.publisher) throw refused(`${keyPath} is not the publisher key of ${ref} (${appFingerprint(manifest.publisher)}): a revocation by any other key is refused by every client`, { reason: "signature-key" });
+	const statement = digests.length ? {
+		ghostlyRevoke: 1,
+		app: ref,
+		digests
+	} : {
+		ghostlyRevoke: 1,
+		app: ref,
+		upTo: what.upTo
+	};
+	if (what.reason !== void 0) statement.reason = what.reason;
+	const problem = checkAppRevokeStatement(statement);
+	if (problem) throw refused("Not a revocation a client reads", {
+		reason: "bad-revocation",
+		detail: problem
+	});
+	let list = [];
+	if (existsSync(listPath)) {
+		const held = readAppRevocations(new Uint8Array(readFileSync(listPath)));
+		if (!held.ok) throw refused(`${listPath} is there and is not a valid ghostly-revoke.json: fix or move it first`, held);
+		list = held.revocations;
+	}
+	const signed = await signAppRevocation(statement, key.signer);
+	const same = list.some((r) => canonicalJson(r.statement) === canonicalJson(signed.statement));
+	if (!same) {
+		if (list.length >= APP_STATEMENT_LIMITS.revocations) throw refused(`${listPath} holds ${list.length} revocations already`, {
+			reason: "bad-revocation",
+			detail: `at most ${APP_STATEMENT_LIMITS.revocations}`
+		});
+		list = [...list, signed];
+		const bytes = canonicalJsonBytes(list);
+		const check = readAppRevocations(bytes);
+		if (!check.ok) throw refused("The revocation list made is not valid", check);
+		writeWhole(listPath, bytes);
+	}
+	return {
+		app: ref,
+		...digests.length ? {
+			digests,
+			current: digests.includes(read.bundle.digest)
+		} : {
+			upTo: what.upTo,
+			current: manifest.sequence <= what.upTo
+		},
+		...what.reason !== void 0 ? { reason: what.reason } : {},
+		added: !same,
+		revocations: list.length,
+		file: listPath
+	};
+}
+/**
+* `store sign <index> --key <file> [--out <dir>]`: a store index written by hand (any JSON layout; `key` may be left
+* out and is then the signing key's) becomes `ghostly-store.json`, canonical, and `ghostly-store.sig`, in `--out` or
+* beside the index. It is read back as a client reads it (`expires` at most 90 days ahead), and refused when the index
+* already there, signed by the same key, has a higher `sequence`, or the same one with other content.
+*/
+async function signStore(indexArg, keyArg, outArg, now = Math.floor(Date.now() / 1e3)) {
+	const indexPath = resolve(indexArg);
+	const keyPath = resolve(keyArg);
+	const outDir = resolve(outArg ?? dirname(indexPath));
+	let value;
+	try {
+		value = JSON.parse(readFileSync(indexPath, "utf8"));
+	} catch (error) {
+		if (error instanceof SyntaxError) throw new CliError("bad_request", `${indexPath} is not JSON: ${error.message}`);
+		throw error;
+	}
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new CliError("bad_request", `${indexPath} is not a JSON object`);
+	const index = value;
+	let key;
+	if (existsSync(keyPath)) key = readKey(keyPath, "store");
+	else if (index.key !== void 0) throw new CliError("not_found", `No key file ${keyPath}: the index names the store key ${typeof index.key === "string" ? appFingerprint(index.key) : JSON.stringify(index.key)}`);
+	else key = makeKey(keyPath, "store");
+	if (index.key !== void 0 && index.key !== key.key) throw refused(`${indexPath} names another store key than ${keyPath}'s (${appFingerprint(key.key)})`, { reason: "store-key" });
+	index.key = key.key;
+	const checked = checkAppStoreIndex(index);
+	if (!checked.ok) throw refused(`${indexPath} is not a valid store index`, checked);
+	const { indexBytes, sigBytes } = await signAppStore(index, key.signer);
+	const read = readAppStore(indexBytes, sigBytes, now, key.key);
+	if (!read.ok) throw refused(`${indexPath} would be refused by a client`, read);
+	const store = read.store;
+	const indexOut = join(outDir, STORE_INDEX_FILE), sigOut = join(outDir, STORE_SIG_FILE);
+	let previous = null;
+	if (existsSync(indexOut) && existsSync(sigOut)) {
+		const held = readAppStore(new Uint8Array(readFileSync(indexOut)), new Uint8Array(readFileSync(sigOut)), now);
+		if (held.ok && held.store.index.key === key.key) {
+			previous = held.store.index.sequence;
+			const decision = appStoreDecision({
+				key: key.key,
+				sequence: held.store.index.sequence,
+				digest: held.store.digest
+			}, {
+				key: key.key,
+				sequence: store.index.sequence,
+				digest: store.digest
+			});
+			if (decision === "rollback" || decision === "equivocation") throw refused(`${indexOut} already holds sequence ${held.store.index.sequence} of this store: ${decision === "rollback" ? "a lower one is refused by every client" : "the same one with other content is refused as equivocation"}; raise sequence`, { reason: decision }, { held: held.store.index.sequence });
+		}
+	}
+	mkdirSync(outDir, { recursive: true });
+	writeWhole(indexOut, indexBytes);
+	writeWhole(sigOut, sigBytes);
+	const notes = [...key.created ? [madeKeyNote(keyPath, "store", key.key)] : [], ...store.expired ? [`expires (${(/* @__PURE__ */ new Date(store.index.expires * 1e3)).toISOString()}) is past: clients still install from it and say the store was not updated since then`] : []];
+	return {
+		key: key.key,
+		fingerprint: appFingerprint(key.key),
+		name: store.index.name,
+		kind: store.index.kind,
+		sequence: store.index.sequence,
+		previous,
+		expires: store.index.expires,
+		expired: store.expired,
+		apps: store.index.apps.length,
+		removed: store.index.removed.length,
+		revoked: store.index.revoked.length,
+		digest: store.digest,
+		index: indexOut,
+		sig: sigOut,
+		keyCreated: key.created,
+		...notes.length ? { warning: notes.join("; ") } : {}
+	};
+}
+//#endregion
+//#region src/commands/apps.ts
+/** The key file a command signs with: always named, never a default, never on the command line itself. */
+function keyFile(value, usage) {
+	if (typeof value !== "string" || !value) throw new CliError("usage", `--key <file> is needed: ghostly ${usage}`);
+	return value;
+}
+var key = {
+	type: "string",
+	description: "The key file (made, owner-only, when it is missing)"
+};
+/**
+* The publisher tools of WISP 1200 (Apps · Publishing): they run here, on files, with no profile or daemon. One entry
+* per command, in alphabetical order (test/commands.test.ts checks).
+*/
+var commands$8 = {
+	"app publish": {
+		method: "app.publish",
+		usage: "app publish <dir> --key <file> [--out <file>]",
+		summary: "Bundle and sign an app (WISP 1200): <dir>/ghostly-app.json and every other file in <dir> become one .ghostlyapp, its sequence one more than the bundle at --out (default <dir>/app.ghostlyapp)",
+		args: ["dir"],
+		options: {
+			key: {
+				...key,
+				description: "The publisher key file (made, owner-only, on first use; back it up)"
+			},
+			out: {
+				type: "string",
+				description: "Where the bundle goes (default <dir>/app.ghostlyapp); the bundle there is the version this one follows"
+			},
+			sequence: {
+				type: "number",
+				description: "This version's sequence, higher than the bundle at --out's (default: one more than it)"
+			}
+		},
+		run: ({ options }, a) => publishApp(a.dir, keyFile(options.key, "app publish <dir> --key <file> [--out <file>] [--sequence n]"), options.out, options.sequence)
+	},
+	"app revoke": {
+		method: "app.revoke",
+		usage: "app revoke <dir> --key <file> (--digest <digest>... | --up-to <sequence>) [--reason <text>] [--bundle <file>]",
+		summary: "Revoke versions of your app (WISP 1200 · Revocation): a ghostly-revoke/1 statement signed with its publisher key, added to <dir>/ghostly-revoke.json",
+		args: ["dir"],
+		options: {
+			key: {
+				type: "string",
+				description: "The app's publisher key file (never made here)"
+			},
+			digest: {
+				type: "list",
+				description: "A version's digest, base64url as app verify prints it (again for each, up to 64)"
+			},
+			"up-to": {
+				type: "number",
+				description: "Every version with this sequence or a lower one"
+			},
+			reason: {
+				type: "string",
+				description: "Why, one line of up to 200 characters, shown to people"
+			},
+			bundle: {
+				type: "string",
+				description: "The bundle naming the app (default <dir>/app.ghostlyapp)"
+			}
+		},
+		run: ({ options }, a) => revokeApp(a.dir, keyFile(options.key, "app revoke <dir> --key <file> (--digest <digest>... | --up-to <sequence>) [--reason <text>]"), {
+			digests: options.digest,
+			upTo: options["up-to"],
+			reason: options.reason,
+			bundle: options.bundle
+		})
+	},
+	"app verify": {
+		method: "app.verify",
+		usage: "app verify <bundle|url>",
+		summary: "Check a .ghostlyapp as a client would, from a file or an https URL: its manifest and digest, or refused (exit 1) with the reason",
+		args: ["bundle"],
+		run: (_, a) => verifyApp(a.bundle)
+	},
+	"store sign": {
+		method: "store.sign",
+		usage: "store sign <index> --key <file> [--out <dir>]",
+		summary: "Sign a store index (WISP 1200 · Stores): writes ghostly-store.json, canonical, and ghostly-store.sig beside it or in --out",
+		args: ["index"],
+		options: {
+			key: {
+				...key,
+				description: "The store key file (made, owner-only, when it is missing and the index names no key; keep it offline)"
+			},
+			out: {
+				type: "string",
+				description: "The folder to write ghostly-store.json and ghostly-store.sig in (default: the index's)"
+			}
+		},
+		run: ({ options }, a) => signStore(a.index, keyFile(options.key, "store sign <index> --key <file> [--out <dir>]"), options.out)
+	}
+};
+//#endregion
 //#region src/commands/shared.ts
 var wait = {
 	wait: {
@@ -12556,6 +14058,82 @@ var taskOptions = {
 	},
 	...cardOptions
 };
+/**
+* `--also week=80` or `--also week=80@2026-10-10T00:00:00Z`: another window of a usage card, its percent left and, after
+* `@`, when it resets.
+*/
+function usageWindowOf(value) {
+	const match = /^([^=]+)=(\d+(?:\.\d+)?)(?:@(.+))?$/.exec(value.trim());
+	if (!match) throw new CliError("usage", `--also takes window=percent or window=percent@time, like week=80@2026-10-10T00:00:00Z, not ${JSON.stringify(value)}`);
+	const resetsAt = cardTime(match[3], "also");
+	return {
+		window: match[1].trim(),
+		left: Number(match[2]),
+		...resetsAt !== void 0 && { resetsAt }
+	};
+}
+/** A usage card's fields from its flags (WISP 405 § Usage); `--json` gives any of them, the flags win over it. */
+function usageFields(options) {
+	const fields = { ...cardJson(options.json) };
+	for (const key of [
+		"id",
+		"left",
+		"used",
+		"limit",
+		"label",
+		"account",
+		"window"
+	]) if (options[key] !== void 0) fields[key] = options[key];
+	const resets = cardTime(options.resets, "resets");
+	if (resets !== void 0) fields.resetsAt = resets;
+	if (Array.isArray(options.also) && options.also.length) fields.windows = options.also.map(usageWindowOf);
+	return fields;
+}
+/** Options `usage send` takes. */
+var usageOptions = {
+	left: {
+		type: "number",
+		description: "Percent of the quota left, 0 to 100"
+	},
+	used: {
+		type: "number",
+		description: "How much is used, with --limit (instead of --left; the percent is worked out)"
+	},
+	limit: {
+		type: "number",
+		description: "The quota, with --used"
+	},
+	label: {
+		type: "string",
+		description: "What the quota is of, like Claude (24 characters)"
+	},
+	account: {
+		type: "string",
+		description: "Which of your accounts it is, short (24 characters)"
+	},
+	window: {
+		type: "string",
+		description: "The quota's window, as people say it: \"5 h\", \"week\" (16 characters)"
+	},
+	resets: {
+		type: "string",
+		description: "When the window starts again: milliseconds or a date like 2026-10-07T18:00:00Z"
+	},
+	also: {
+		type: "list",
+		description: "Another window, window=percent[@time], like week=80@2026-10-10T00:00:00Z (up to 3; shown in the details)"
+	},
+	id: {
+		type: "string",
+		description: "The card's id (default usage: one card per chat)"
+	},
+	all: {
+		type: "boolean",
+		description: "Every 1:1 chat with a contact, instead of one chat"
+	},
+	json: cardOptions.json,
+	text: cardOptions.text
+};
 //#endregion
 //#region src/commands/calls.ts
 /** Voice calls: one entry per command, in alphabetical order (test/commands.test.ts checks). */
@@ -13054,6 +14632,27 @@ var commands$6 = {
 			status: options.status,
 			for: options.for
 		})
+	},
+	"usage send": {
+		method: "usage.send",
+		usage: "usage send [<chat|group>] [--all] --left <percent> [--window \"5 h\"] [--resets <time>] [--label Claude] [--account <name>] [--also week=80@<time>]... [--used n --limit n] [--id id] [--json json|-|file] [--wait none|sent] [--timeout s]",
+		summary: "Say how much of your quota is left (a bot's usage card, one per chat, updated in place); --all for every 1:1 chat",
+		args: ["chat?"],
+		options: {
+			...usageOptions,
+			...groupWait
+		},
+		params: ({ options }, { chat }) => {
+			if (!chat && options.all !== true) throw new CliError("usage", "Name a chat or group, or give --all: ghostly usage send <chat|--all> --left <percent>");
+			return {
+				chat,
+				all: options.all === true,
+				card: usageFields(options),
+				text: options.text,
+				wait: options.wait,
+				timeout: options.timeout
+			};
+		}
 	}
 };
 //#endregion
@@ -13063,7 +14662,7 @@ var commands$5 = {
 	"file accept": {
 		method: "file.action",
 		usage: "file accept [<chat>] <file>",
-		summary: "Take a file the contact offers",
+		summary: "Take a file the contact offers, or download a group's file that did not come by itself (<chat> may be the group)",
 		args: ["chat?", "file"],
 		params: (_, a) => ({
 			chat: a.chat,
@@ -13095,8 +14694,8 @@ var commands$5 = {
 	},
 	"file list": {
 		method: "file.list",
-		usage: "file list <chat>",
-		summary: "A chat's files and their transfers",
+		usage: "file list <chat|group>",
+		summary: "A chat's or a group's files and their transfers",
 		args: ["chat"],
 		params: (_, { chat }) => ({ chat })
 	},
@@ -13114,7 +14713,7 @@ var commands$5 = {
 	"file request": {
 		method: "file.action",
 		usage: "file request [<chat>] <file>",
-		summary: "Ask again for a file that stopped arriving: it goes on from what is here",
+		summary: "Ask again for a file that stopped arriving: it goes on from what is here (a group's file: asked of whoever holds it)",
 		args: ["chat?", "file"],
 		params: (_, a) => ({
 			chat: a.chat,
@@ -13183,13 +14782,13 @@ var commands$5 = {
 	},
 	"file send": {
 		method: "file.send",
-		usage: "file send <chat> <path> [--name n] [--mime t] [--voice [ms] [--peaks 0,40,…]] [--reply <message>]",
-		summary: "Send a file (or, with --voice, a voice note), as a reply with --reply",
+		usage: "file send <chat|group> <path> [--name n] [--mime t] [--voice [ms] [--peaks 0,40,…]] [--reply <message>]",
+		summary: `Send a file (or, with --voice, a voice note), as a reply with --reply; to a group, every member's app fetches it (up to ${GROUP_FILE_LIMITS.maxBytes / 1024 / 1024} MiB)`,
 		args: ["chat", "path"],
 		options: {
 			name: {
 				type: "string",
-				description: "The name the contact sees"
+				description: "The name the contact (or the group) sees"
 			},
 			mime: {
 				type: "string",
@@ -14055,7 +15654,8 @@ var COMMANDS = {
 	...commands$1,
 	...commands$2,
 	...commands,
-	...commands$7
+	...commands$7,
+	...commands$8
 };
 /** Commands that take text (argument or stdin), with the secret guard and delivery waits. */
 var TEXT_COMMANDS = {
@@ -14668,10 +16268,11 @@ function loadCallStack() {
 }
 /**
 * The ICE servers of a call, as libdatachannel takes them: the apps' STUN servers (RTC_CONFIG; libjuice uses the
-* first), then the profile's own (Settings `iceServers`: a TURN relay, typically), as the apps' calls use them.
+* first; none with `GHOSTLY_STUN=0`), then the profile's own (Settings `iceServers`: a TURN relay, typically), as the
+* apps' calls use them.
 */
-function callIceServers(extra = []) {
-	const out = (RTC_CONFIG.iceServers ?? []).flatMap((server) => [server.urls].flat()).slice(0, 2);
+function callIceServers(extra = [], env = process.env) {
+	const out = env.GHOSTLY_STUN === "0" ? [] : (RTC_CONFIG.iceServers ?? []).flatMap((server) => [server.urls].flat()).slice(0, 2);
 	for (const server of callRtcConfig(extra).iceServers?.slice(RTC_CONFIG.iceServers?.length ?? 0) ?? []) for (const url of [server.urls].flat()) {
 		const m = /^(stun|turns?):([^:?\s]+)(?::(\d+))?(?:\?transport=(udp|tcp))?$/i.exec(url);
 		if (!m) continue;
@@ -15734,8 +17335,11 @@ var EventHub = class {
 			const shape = `${transfer.state}|${transfer.stage ?? ""}`, before = this.transfers.get(id);
 			this.transfers.set(id, shape);
 			if (quiet || before === shape) continue;
+			const chat = state.links.find((l) => id.startsWith(`${l.id}-`))?.id ?? null;
+			const group = chat ? void 0 : state.groups.find((g) => id.startsWith(`group-${g.id}-`))?.id;
 			const fields = {
-				chat: state.links.find((l) => id.startsWith(`${l.id}-`))?.id ?? null,
+				chat,
+				...group ? { group } : {},
 				file: id,
 				direction: transfer.direction ?? (id.includes("-in-") ? "in" : "out"),
 				size: transfer.size,
@@ -16050,6 +17654,203 @@ function groupShape(group) {
 	};
 }
 //#endregion
+//#region ../browser/src/platform/irohWeb.ts
+/**
+* Iroh (WISP 102) in a browser: the same QUIC/TLS session and binding as the
+* Desktop's native Iroh, but relay only. A page cannot send UDP, so every
+* packet goes through an Iroh relay over a WebSocket; the relay sees who talks
+* to whom and when, never the frames.
+*
+* The wasm (about 1 MB gzip) loads on the first chat that starts an endpoint,
+* never on the app's first load.
+*/
+/**
+* n0's public relays, the same ones the Desktop's Iroh homes on by default. Iroh itself names them with the trailing
+* dot of a full domain name (`use1-1.relay.n0.iroh.link.`), and compares relay URLs as text; here they have none,
+* because WebKit opens no host name that ends in a dot. `BROWSER_SPELLING` is what keeps the two one relay.
+*/
+var DEFAULT_IROH_RELAYS = [
+	"https://use1-1.relay.n0.iroh.link/",
+	"https://euc1-1.relay.n0.iroh.link/",
+	"https://aps1-1.relay.n0.iroh.link/",
+	"https://usw1-1.relay.n0.iroh.link/"
+];
+/**
+* The spelling of every relay URL handed to the wasm Iroh (`irohRelayUrl`): the relays it homes on and a contact's
+* relay before a dial. One spelling, so a contact on this endpoint's relay is reached over the connection already
+* open to it; without the dot, so Safari can open it (a Desktop's record names its relay with the dot).
+*/
+var BROWSER_SPELLING = "plain";
+/**
+* Why a relay URL cannot be used, or null. TLS, except on this machine (a local `iroh-relay --dev`): a page
+* may not open plain WebSockets elsewhere, and the relay's operator would see traffic metadata in the clear.
+*/
+function irohRelayProblem(value) {
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		return `Not a relay address: ${value}`;
+	}
+	const local = [
+		"localhost",
+		"127.0.0.1",
+		"[::1]"
+	].includes(url.hostname);
+	if (url.protocol !== "https:" && !(url.protocol === "http:" && local)) return `Use an https:// relay address: ${value}`;
+	if (url.username || url.password || url.search || url.hash || value.length > 256) return `Not a relay address: ${value}`;
+	return null;
+}
+var loaded = null;
+/** Loads the wasm once per page. Tests pass their own `load` (Node reads the file). */
+function loadIrohWasm() {
+	loaded ??= import("./assets/ghostly_iroh_web-Dvzh3Y6E.js").then(async (module) => {
+		await module.default();
+		return module;
+	}).catch((error) => {
+		loaded = null;
+		throw error;
+	});
+	return loaded;
+}
+var SEND_BUDGET = 122880;
+var MAX_FRAME = 61440;
+/** One paired channel over one QUIC stream. Sends are queued in order. */
+var IrohWebChannel = class {
+	conn;
+	forget;
+	reader = null;
+	buffered = [];
+	queue = Promise.resolve();
+	closed = false;
+	bufferedAmount = 0;
+	sendBudget = SEND_BUDGET;
+	onClose = null;
+	constructor(conn, forget) {
+		this.conn = conn;
+		this.forget = forget;
+		this.read();
+	}
+	get onMessage() {
+		return this.reader;
+	}
+	set onMessage(reader) {
+		this.reader = reader;
+		if (reader) for (const text of this.buffered.splice(0)) reader(text);
+	}
+	async read() {
+		try {
+			for (;;) {
+				const text = await this.conn.recv();
+				if (text === void 0 || this.closed) break;
+				if (this.reader) this.reader(text);
+				else if (this.buffered.length < 64) this.buffered.push(text);
+				else break;
+			}
+		} catch {}
+		this.close();
+	}
+	send(data) {
+		if (typeof data !== "string" || this.closed || !data.length || data.length > MAX_FRAME || this.bufferedAmount + data.length > SEND_BUDGET) throw new Error("Iroh channel is closed or its send budget is full");
+		this.bufferedAmount += data.length;
+		this.queue = this.queue.then(() => this.closed ? void 0 : this.conn.send(data)).catch(() => this.close()).finally(() => {
+			this.bufferedAmount -= data.length;
+		});
+	}
+	drained() {
+		return this.queue;
+	}
+	get rttMs() {
+		const rtt = this.conn.rtt();
+		return rtt >= 0 ? rtt : void 0;
+	}
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		this.buffered = [];
+		try {
+			this.conn.close();
+		} catch {}
+		this.forget();
+		this.onClose?.();
+	}
+};
+/** A NativeEndpoint for `iroh/1`, as the Desktop's is, for one chat's transport seed. */
+async function createIrohWebEndpoint(seedB64, options = {}) {
+	const seed = fromBase64Url$1(seedB64);
+	if (seed.length !== 32) throw new Error("Invalid transport seed");
+	const relays = [...new Set((options.relays?.length ? options.relays : DEFAULT_IROH_RELAYS).map((relay) => irohRelayUrl(relay, BROWSER_SPELLING)))];
+	const node = await (await (options.load ?? loadIrohWasm)()).IrohNode.start(seed, relays, options.onlineMs ?? 1e4);
+	const channels = /* @__PURE__ */ new Set();
+	let stopped = false;
+	let handler = null;
+	const early = [];
+	const bind = (conn) => {
+		const channel = new IrohWebChannel(conn, () => channels.delete(channel));
+		channels.add(channel);
+		return {
+			channel,
+			binding: conn.binding()
+		};
+	};
+	const endpoint = {
+		transport: "iroh/1",
+		descriptor: {
+			...node.address(),
+			relayed: true
+		},
+		onDescriptor: null,
+		get onConnection() {
+			return handler;
+		},
+		set onConnection(value) {
+			handler = value;
+			if (value) for (const bound of early.splice(0)) value(bound);
+		},
+		async connect(descriptor) {
+			if (stopped) throw new Error("Iroh endpoint is stopped");
+			const conn = await node.connect(irohDescriptor(descriptor, BROWSER_SPELLING), options.connectMs ?? 2e4);
+			if (stopped) {
+				conn.close();
+				throw new Error("Iroh endpoint is stopped");
+			}
+			return bind(conn);
+		},
+		async close() {
+			if (stopped) return;
+			stopped = true;
+			for (const channel of [...channels]) channel.close();
+			for (const bound of early.splice(0)) bound.channel.close();
+			await node.close().catch(() => {});
+		}
+	};
+	(async () => {
+		while (!stopped) {
+			let conn;
+			try {
+				conn = await node.accept();
+			} catch {
+				break;
+			}
+			if (!conn) break;
+			if (stopped) {
+				conn.close();
+				break;
+			}
+			const bound = bind(conn);
+			const accept = endpoint.onConnection;
+			if (accept) accept(bound);
+			else if (early.length < 4) early.push(bound);
+			else bound.channel.close();
+		}
+		if (!stopped) {
+			endpoint.onUnavailable?.();
+			await endpoint.close();
+		}
+	})();
+	return endpoint;
+}
+//#endregion
 //#region ../browser/src/engine/paymentAdapters/fedimintSdk.ts
 var fedimintDatabase = (id) => `ghostly-fedimint-${id}.db`;
 var MODULE_WASM = () => import("./assets/fedimint_client_wasm_bg-BtHHlFpp.js");
@@ -16936,6 +18737,39 @@ function pkarrRelays(env = process.env) {
 	return relays;
 }
 /**
+* The Iroh relays of a private network or a test, `GHOSTLY_IROH_RELAYS` ("https://…,…"; http:// on loopback): the only
+* relays this process's Iroh homes on, whatever the profile's `irohRelays` setting says. Null when unset (the setting,
+* else n0's public relays).
+*/
+function irohRelays(env = process.env) {
+	const relays = (env.GHOSTLY_IROH_RELAYS ?? "").split(",").map((url) => url.trim()).filter(Boolean);
+	if (!relays.length) return null;
+	const bad = relays.map((url) => irohRelayProblem(url)).find(Boolean);
+	if (bad) throw new CliError("usage", `GHOSTLY_IROH_RELAYS: ${bad}`);
+	return relays;
+}
+/**
+* The apps' public STUN servers (Google's, `RTC_CONFIG`), which every WebRTC connection asks for its public address:
+* `GHOSTLY_STUN=0` leaves them out (a private network, or tests on one machine, where host candidates connect). The
+* profile's own `iceServers` stay.
+*/
+function publicStun(env = process.env) {
+	return env.GHOSTLY_STUN !== "0";
+}
+/** An RTC configuration without the apps' public STUN servers. */
+function withoutPublicStun(config) {
+	if (!config?.iceServers) return config;
+	const ours = new Set((RTC_CONFIG.iceServers ?? []).flatMap((server) => [server.urls].flat()));
+	const iceServers = config.iceServers.map((server) => ({
+		...server,
+		urls: [server.urls].flat().filter((url) => !ours.has(url))
+	})).filter((server) => server.urls.length);
+	return {
+		...config,
+		iceServers
+	};
+}
+/**
 * The Mainline DHT, for Pkarr beside the relays (`RelaysAndDht`): `GHOSTLY_DHT=0` leaves it out (relays only, as the web
 * app), `GHOSTLY_DHT_BOOTSTRAP` ("host:port,…") replaces the public routers (a testnet; one all on loopback binds there).
 * `GHOSTLY_PKARR_RELAYS` without a bootstrap leaves it out too, as on the Desktop: a private network stays off the
@@ -16971,12 +18805,43 @@ async function installWebRtc() {
 			"RTCPeerConnectionIceEvent",
 			"RTCCertificate"
 		]) scope[name] ??= polyfill[name];
+		refuseDataAnswers(scope);
+		if (!publicStun()) leaveOutPublicStun(scope);
 		return true;
 	} catch (error) {
 		process.stderr.write(`ghostly: WebRTC is unavailable (${error instanceof Error ? error.message : String(error)}); chats use HyperDHT, Iroh or the DHT\n`);
 		return false;
 	}
 }
+/**
+* For tests: `GHOSTLY_TEST_REFUSE_DATA_ANSWERS=<n>` refuses one in every n answers this process applies to its offers
+* (the first, the n+1st, and so on), as libdatachannel 0.24.5 refuses one in its race (`ANSWER_REFUSED_REDIALS` in
+* packages/core/src/datalink.ts): the connection closes, and setRemoteDescription throws.
+*/
+function refuseDataAnswers(scope) {
+	const every = Number(process.env.GHOSTLY_TEST_REFUSE_DATA_ANSWERS) || 0;
+	if (every <= 0) return;
+	let answers = 0;
+	const Base = scope.RTCPeerConnection;
+	scope.RTCPeerConnection = class extends Base {
+		async setRemoteDescription(description) {
+			if (description.type === "answer" && answers++ % every === 0) {
+				this.close();
+				throw new Error("libdatachannel error while adding remote description: Got a remote candidate without ICE transport (GHOSTLY_TEST_REFUSE_DATA_ANSWERS)");
+			}
+			return super.setRemoteDescription(description);
+		}
+	};
+}
+/** `GHOSTLY_STUN=0`: every connection the engine makes leaves the apps' public STUN servers out of its configuration. */
+function leaveOutPublicStun(scope) {
+	const Base = scope.RTCPeerConnection;
+	scope.RTCPeerConnection = class extends Base {
+		constructor(config) {
+			super(withoutPublicStun(config));
+		}
+	};
+}
 /** Server-sent events, which browsers have and Node does not: Arkade follows its server with them. */
 async function installEventSource() {
 	const scope = globalThis;
@@ -17017,13 +18882,17 @@ function leftOutIn(mark) {
 }
 async function startRuntime(paths, options = {}) {
 	const pinned = pkarrRelays();
+	const pinnedIroh = irohRelays();
 	const trace = process.env.GHOSTLY_LINK_TRACE;
-	if (trace) setLinkTraceSink((line) => appendFileSync(trace, line + "\n", { mode: 384 }));
+	if (trace) {
+		setLinkTraceSink((line) => appendFileSync(trace, line + "\n", { mode: 384 }));
+		(await import("./assets/joinTrace-CO8mlhNO.js").then((n) => n.t)).setJoinTraceSink((line) => appendFileSync(trace, line + "\n", { mode: 384 }));
+	}
 	const store = await openPersistentIndexedDb(paths.db);
 	const restored = join(paths.dir, RESTORED_MARK);
 	if (existsSync(restored)) {
 		try {
-			const rows = await import("./assets/restoredRows-C1O9FfA4.js");
+			const rows = await import("./assets/restoredRows-lhTKGmCO.js");
 			await rows.markRestoredWallet();
 			await rows.markLeftOutFiles(leftOutIn(restored));
 			await store.compact();
@@ -17042,19 +18911,20 @@ async function startRuntime(paths, options = {}) {
 	await installEventSource();
 	await preloadWalletModules();
 	(await import("./assets/ghostly_iroh_web-Dvzh3Y6E.js")).initSync({ module: irohWasmBytes() });
-	const [{ registerFileBytes }, { NodeFileBytes }] = await Promise.all([import("./assets/fileBytes-DxiJHmTk.js").then((n) => n.o), import("./assets/fileBytes-BQ84L9Fe.js")]);
+	const [{ registerFileBytes }, { NodeFileBytes }] = await Promise.all([import("./assets/fileBytes-3AQ2tJzW.js").then((n) => n.o), import("./assets/fileBytes-CAZDydIe.js")]);
 	registerFileBytes("native", async () => new NodeFileBytes(paths.files), true);
-	const [{ EngineServer }, { createHyperEndpoint }] = await Promise.all([import("./assets/server-CXFTDnFI.js").then((n) => n.t), import("./assets/endpoint-CaSbSFDw.js")]);
+	const [{ EngineServer }, { createHyperEndpoint }] = await Promise.all([import("./assets/server-HMzdsyn_.js").then((n) => n.t), import("./assets/endpoint-D_3bYafG.js")]);
 	const network = hyperdhtNetwork();
 	const dht = mainlineNetwork();
-	const mainline = dht.off ? null : new (await (import("./assets/mainline-dkA94eh2.js"))).Mainline({
+	const mainline = dht.off ? null : new (await (import("./assets/mainline-DQxDSWXm.js"))).Mainline({
 		bootstrap: dht.bootstrap,
 		host: dht.host
 	});
-	const transport = mainline || pinned ? new (await (import("./assets/mainline-dkA94eh2.js"))).RelaysAndDht(mainline, pinned ? { relays: pinned } : {}, !!pinned) : null;
+	const transport = mainline || pinned ? new (await (import("./assets/mainline-DQxDSWXm.js"))).RelaysAndDht(mainline, pinned ? { relays: pinned } : {}, !!pinned) : null;
 	const server = new EngineServer({
 		...transport ? { transport } : {},
 		irohWeb: true,
+		...pinnedIroh ? { irohRelays: pinnedIroh } : {},
 		singleDevice: true,
 		nativeTransports: { "hyperdht/1": (seedB64) => createHyperEndpoint(fromBase64Url$1(seedB64), network) },
 		automaticWallets: false,
@@ -17574,6 +19444,7 @@ async function warnVersion(client) {
 */
 function chatOnly(method, params) {
 	if (method.startsWith("task.") || method.startsWith("routine.") || method.startsWith("button.")) return false;
+	if (method === "usage.send") return params.all === true;
 	return method.startsWith("chat.") || params.chat !== void 0 && params.group === void 0 && !method.startsWith("group.");
 }
 async function session(g, chat = false) {
@@ -18448,6 +20319,15 @@ async function tableCommand(name, argv) {
 	const g = globals(parsed);
 	pretty = g.pretty;
 	const args = positionals(command, parsed.positionals);
+	if (command.run) {
+		const result = await command.run(parsed, args);
+		if (typeof result.warning === "string") {
+			process.stderr.write(`ghostly: ${result.warning}\n`);
+			delete result.warning;
+		}
+		print(result);
+		return;
+	}
 	const params = command.params?.(parsed, args) ?? {};
 	for (const key of Object.keys(params)) if (params[key] === void 0) delete params[key];
 	if (command.method === "identity.complete") {
@@ -18623,6 +20503,6 @@ async function run(argv) {
 //#region src/bin.ts
 run(process.argv.slice(2));
 //#endregion
-export { onAdaptersChanged as $, intentRepository as A, MESSAGE_DETAILS_MAX_BYTES as B, ProviderSources as C, FileAppender as Ct, requireTurn as D, streamStored as Dt, refuseAway as E, storedSize as Et, ModeGate as F, fakesLightning as G, BITCOIN_INVOICE_ON_TESTNET as H, WrongNetworkError as I, mintNetwork as J, isTestMint as K, networkLabel as L, sealSeed as M, unsealSeed as N, setAwayWallets as O, ModeChanged as P, identityProviders as Q, CASHU_MINT_SOURCE as R, lightningPaying as S, paymentWireId as St, awayFrom as T, removeStored as Tt, DEFAULT_MINTS as U, WALLET_TYPES as V, TEST_MINT as W, BACKUP_MEDIA_TYPE as X, paysItsOwnInvoices as Y, MAX_BACKUP_BYTES as Z, normalizePhrase as _, pairedWireReply as _t, createFailure as a, SourceConfigError as at, breezDatabasesFor as b, replyTo as bt, paymentNetwork as c, networkMode as ct, networkReason as d, resolveAtprotoDid as dt, registeredLightningProviders as et, rpcHost as f, setOwnDidSource as ft, isRecoveryPhrase as g, groupReply as gt, cardsKey as h, chosenResolver as ht, assertConfirmedReal as i, PROVIDER_PLATFORMS as it, newDeviceKey as j, setSingleWriterGate as k, paymentNetworksOf as l, redact as lt, LightningCards as m, verifyIdentity as mt, loadFedimintSdk as n, reserveAdapterIds as nt, createTiming as o, SourceUnreachableError as ot, CASHU_CARD as p, boundedIdentityFetch as pt, isWorthlessMint as q, WALLET_NAMES as r, NothingSpentError as rt, crossNetwork as s, isNothingSpentError as st, fedimintDatabase as t, registeredOnchainProviders as tt, walletInstances as u, assertPublicServer as ut, breezDatabase as v, receivedPairedReply as vt, sourceKey as w, readStored as wt, dropBreezDatabase as x, paymentAlias as xt, breezDatabaseInUse as y, replyRef as yt, cashuMint as z };
+export { BACKUP_MEDIA_TYPE as $, requireTurn as A, paymentWireId as At, networkLabel as B, breezDatabasesFor as C, storedGroupFiles as Ct, sourceKey as D, replyRef as Dt, ProviderSources as E, receivedPairedReply as Et, sealSeed as F, streamStored as Ft, BITCOIN_INVOICE_ON_TESTNET as G, cashuMint as H, unsealSeed as I, fakesLightning as J, DEFAULT_MINTS as K, ModeChanged as L, setSingleWriterGate as M, readStored as Mt, intentRepository as N, removeStored as Nt, awayFrom as O, replyTo as Ot, newDeviceKey as P, storedSize as Pt, paysItsOwnInvoices as Q, ModeGate as R, breezDatabaseInUse as S, groupOfFile as St, lightningPaying as T, pairedWireReply as Tt, MESSAGE_DETAILS_MAX_BYTES as U, CASHU_MINT_SOURCE as V, WALLET_TYPES as W, isWorthlessMint as X, isTestMint as Y, mintNetwork as Z, LightningCards as _, verifyIdentity as _t, irohRelayProblem as a, reserveAdapterIds as at, normalizePhrase as b, groupFileId as bt, createFailure as c, SourceConfigError as ct, paymentNetwork as d, networkMode as dt, MAX_BACKUP_BYTES as et, paymentNetworksOf as f, redact as ft, CASHU_CARD as g, boundedIdentityFetch as gt, rpcHost as h, setOwnDidSource as ht, createIrohWebEndpoint as i, registeredOnchainProviders as it, setAwayWallets as j, FileAppender as jt, refuseAway as k, paymentAlias as kt, createTiming as l, SourceUnreachableError as lt, networkReason as m, resolveAtprotoDid as mt, loadFedimintSdk as n, onAdaptersChanged as nt, WALLET_NAMES as o, NothingSpentError as ot, walletInstances as p, assertPublicServer as pt, TEST_MINT as q, DEFAULT_IROH_RELAYS as r, registeredLightningProviders as rt, assertConfirmedReal as s, PROVIDER_PLATFORMS as st, fedimintDatabase as t, identityProviders as tt, crossNetwork as u, isNothingSpentError as ut, cardsKey as v, chosenResolver as vt, dropBreezDatabase as w, groupReply as wt, breezDatabase as x, groupFileText as xt, isRecoveryPhrase as y, GroupFileDesk as yt, WrongNetworkError as z };
 
 //# sourceMappingURL=ghostly.mjs.map