@ghostlytools/cli 1.1.5 → 1.1.7

package/dist/ghostly.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { t as __exportAll } from "./assets/rolldown-runtime-8H4AJuhK.js";
-import { $ as parseSshSignature, Aa as APP_STATEMENT_LIMITS, Ac as toZ32, Ai as irohDescriptor, An as normalizeDomain, Ar as TYPING_REFRESH_MS, At as didWebFile, Ba as canonicalJsonBytes, Bi as sanitizeFileName, Bn as decodeBolt11, Bt as strictBase64Url, Cn as decodeDnsResponse, Ct as DidError, Dc as fromBase64Url$1, Dn as encodeDnsQuery, Dt as didJwsAlg, En as domainWellKnownFile, Et as didGhostlyServiceEntry, Fn as wellKnownUrl, Ft as parseDid, Gt as resolveDidDht, Hi as PLAYABLE_AUDIO, Hs as seedSigner, Ia as readAppRevocations, In as requestLnurlInvoice, It as parseDidDocument, J as groupName, Jr as checkPushEndpoint, Ki as parseVoiceMeta, La as signAppObject, Ln as resolveLightningDestination, Lt as parseDidSignaturePaste, Ma as appRef, Mc as utf8Encode, Mn as recordsFromWellKnown, Mr as sanitizeTypingStatus, Mt as didWebFileUrl, Na as checkAppRevokeStatement, Nn as recordsName, Nt as didWebHost, Oc as randomBytes$1, On as isPublicAddress, Ot as didSignedMessages, Pn as txtValue, Pt as normalizeDid, Q as parseSshPublicKey, Qr as BUTTONS_CAPABILITY, Ra as signAppRevocation, Ri as readImageMeta, Rn as engineError, Rt as signingKeys, Sn as DOMAIN_FILE_MAX_BYTES, Tc as sanitizeAvatar, Tn as domainTxtRecord, Tt as checkDidSignature, Ui as VOICE_LIMITS, Vi as sanitizeMime, Wi as baseMime, X as SSHSIG_NAMESPACE, Z as SshSigError, Za as GhostlyHttpError, _a as ITEM_STATES, _c as openRelayPayload, _i as boundVerifiedIdentity, _n as pubkyProofCapability, _t as shortAtprotoDid, a as checkAppStoreIndex, ao as RTC_CONFIG, at as decodeAnyBitcoinAddress, ba as buttonLabelClash, bi as identityStatement, bn as homeserverWebEndpoint, bt as DID_DOCUMENT_MAX_BYTES$1, c as APP_BUNDLE_LIMITS, cc as setLinkTraceSink, co as callRtcConfig, ct as ATPROTO_PROOF_COLLECTION, d as assembleAppBundle, do as parseCallSignal, dt as atprotoProofRecord, et as sameSshKey, f as checkAppManifest, fn as PUBKY_PROOF_MAX_BYTES, fo as signalHasVideo, ft as atprotoProofRkey, gn as normalizePubkyKey, gt as parseAtprotoDidDocument, ha as replySnippet, hi as IdentityCheckUnavailable, hn as newPubkyProofFolder, ht as normalizeAtprotoHandle, io as CALL_SIGNAL_MAX_AGE_MS, it as BitcoinAddressError, ja as appFingerprint, jc as utf8Decode, ji as irohRelayUrl, jn as recordsFromTxt, js as inviteLink, jt as didWebFileNames, ka as APP_PREFIXES, kc as toBase64Url$1, kn as nip05RootKey, kr as TYPING_KINDS, kt as didWebDocumentUrl, lo as callSignalHeardAt, lt as ATPROTO_PROOF_SCOPE, m as readAppBundle, mc as RELAY_PAYLOAD_MAX_BYTES, mn as isPubkyProofFolder, mt as isAtprotoDid, nt as verifySshSignature, o as readAppStore, on as walletNetworkOf, oo as answersOffer, ot as ATPROTO_DECLARED_SCOPE, p as isAppUrl, pn as isPubkyKey, pt as checkAtprotoProofRecord, qi as voicePeaksOf, rt as verifyBitcoinMessage, s as signAppStore, so as buildSdpFromSignal, st as ATPROTO_FULL_SCOPE, t as appStoreDecision, tn as WALLET_NETWORKS, to as LIMITS, tt as sshSignCommand, uo as extractParamsFromSdp, ut as atprotoDidMethod, va as RUN_RESULTS, vn as pubkyProofFile, vt as AtprotoProofError, wc as MAX_AVATAR_LENGTH, wn as dnsProofName, wt as checkDidJws, xa as checkStatusCard, xn as pubkyHomeserverOf, xt as DID_FILE_MAX_BYTES, ya as STATUS_CARD_LIMITS, yn as pubkyProofPath, yt as verifyAtprotoRecordProof, za as canonicalJson, zn as engineText, zt as staticDidDocument } from "./assets/src-C6qQYrAH.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-Cp3o_yHN.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";
@@ -35,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.5",
+	version: "1.1.7",
 	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",
@@ -674,6 +674,7 @@ var ENGINE_METHODS = [
 	"disableGroupLink",
 	"joinGroupByLink",
 	"sendGroupMessage",
+	"sendGroupFile",
 	"pressButton",
 	"groupMessages",
 	"messagePage",
@@ -1040,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
@@ -1458,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",
@@ -1501,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",
@@ -1522,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 {
@@ -1531,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)`);
@@ -1539,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));
@@ -1620,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
@@ -1659,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) => {
@@ -1680,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
@@ -1936,7 +2776,7 @@ async function sendCard(ctx, params, kind) {
 			status: "running",
 			startedAt: now,
 			updatedAt: now
-		} : { state: "active" },
+		} : kind === "routine" ? { state: "active" } : {},
 		...fields,
 		kind,
 		id
@@ -2059,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"),
@@ -2067,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
@@ -13140,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). */
@@ -13638,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
@@ -13647,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,
@@ -13679,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 })
 	},
@@ -13698,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,
@@ -13767,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",
@@ -16320,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,
@@ -17895,14 +18913,14 @@ async function startRuntime(paths, options = {}) {
 	(await import("./assets/ghostly_iroh_web-Dvzh3Y6E.js")).initSync({ module: irohWasmBytes() });
 	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-TamKsfmC.js").then((n) => n.t), import("./assets/endpoint-CaSbSFDw.js")]);
+	const [{ EngineServer }, { createHyperEndpoint }] = await Promise.all([import("./assets/server-GJW_5wGI.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-BabMhm8L.js"))).Mainline({
+	const mainline = dht.off ? null : new (await (import("./assets/mainline-B7wHcLaW.js"))).Mainline({
 		bootstrap: dht.bootstrap,
 		host: dht.host
 	});
-	const transport = mainline || pinned ? new (await (import("./assets/mainline-BabMhm8L.js"))).RelaysAndDht(mainline, pinned ? { relays: pinned } : {}, !!pinned) : null;
+	const transport = mainline || pinned ? new (await (import("./assets/mainline-B7wHcLaW.js"))).RelaysAndDht(mainline, pinned ? { relays: pinned } : {}, !!pinned) : null;
 	const server = new EngineServer({
 		...transport ? { transport } : {},
 		irohWeb: true,
@@ -18426,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) {
@@ -19484,6 +20503,6 @@ async function run(argv) {
 //#region src/bin.ts
 run(process.argv.slice(2));
 //#endregion
-export { BACKUP_MEDIA_TYPE as $, requireTurn as A, streamStored as At, networkLabel as B, breezDatabasesFor as C, replyTo as Ct, sourceKey as D, readStored as Dt, ProviderSources as E, FileAppender as Et, sealSeed as F, 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, intentRepository as N, awayFrom as O, removeStored as Ot, newDeviceKey as P, paysItsOwnInvoices as Q, ModeGate as R, breezDatabaseInUse as S, replyRef as St, lightningPaying as T, paymentWireId 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, pairedWireReply 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, refuseAway as k, storedSize 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, paymentAlias as wt, breezDatabase as x, receivedPairedReply as xt, isRecoveryPhrase as y, groupReply as yt, WrongNetworkError 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