@ghostlytools/cli 1.2.2 → 1.2.3

package/dist/ghostly.mjs

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
 import { t as __exportAll } from "./assets/rolldown-runtime-8H4AJuhK.js";
-import { $ as groupName, $a as APP_PREFIXES, $c as sanitizeAvatar, $n as readGroupWantNo, At as checkDidSignature, Ba as RUN_RESULTS, Bo as signalHasVideo, Bt as parseDid, Ci as recordsFromWellKnown, Cn as pubkyProofFile, Ct as AtprotoProofError, Dn as requestLnurlInvoice, Dr as ChatFiles, Ei as wellKnownUrl, En as pubkyHomeserverOf, Et as DID_FILE_MAX_BYTES, Fa as replySnippet, Fo as buildSdpFromSignal, Ft as didWebFile, Ga as checkStatusCard, Gc as openRelayPayload, Gt as strictBase64Url, Ha as buttonLabelClash, Hc as RELAY_PAYLOAD_MAX_BYTES, Hn as engineText, Ht as parseDidSignaturePaste, Ic as setLinkTraceSink, Ii as boundVerifiedIdentity, Io as callRtcConfig, It as didWebFileNames, Jn as groupFileFallback, Kn as GROUP_WANT_NO_FRAME, La as ITEM_STATES, Lo as callSignalHeardAt, Lt as didWebFileUrl, Mo as CALL_SIGNAL_MAX_AGE_MS, Mr as TYPING_REFRESH_MS, Mt as didJwsAlg, No as RTC_CONFIG, Nt as didSignedMessages, On as resolveLightningDestination, Ot as DidError, Pi as IdentityCheckUnavailable, Po as answersOffer, Pr as sanitizeTypingStatus, Pt as didWebDocumentUrl, Qc as MAX_AVATAR_LENGTH, Qn as readGroupWant, Ra as PR_CHECKS, Ro as extractParamsFromSdp, Rt as didWebHost, Si as recordsFromTxt, Sn as pubkyProofCapability, St as shortAtprotoDid, Ti as txtValue, Tn as homeserverWebEndpoint, To as GhostlyHttpError, Tt as DID_DOCUMENT_MAX_BYTES$1, Ua as cardLine, Un as GROUP_FILE_LIMITS, Ut as signingKeys, Va as STATUS_CARD_LIMITS, Vn as engineError, Vt as parseDidDocument, Wa as cardUrl, Wn as GROUP_HAVE_FRAME, Wt as staticDidDocument, Xi as irohRelayUrl, Xr as checkPushEndpoint, Xt as resolveDidDht, Yi as irohDescriptor, Yn as isGroupMessageId, Zn as readGroupHave, _ as checkAppManifest, _a as RateWindow, _i as domainWellKnownFile, _n as PUBKY_PROOF_MAX_BYTES, _t as atprotoProofRkey, ac as inviteLink, al as utf8Decode, at as sameSshKey, bi as nip05RootKey, bn as newPubkyProofFolder, bt as normalizeAtprotoHandle, c as readAppStore, ca as PLAYABLE_AUDIO, co as signAppObject, ct as verifyBitcoinMessage, d as APP_BUNDLE_LIMITS, da as fileMessageText, dn as walletNetworkOf, do as canonicalJsonBytes, dt as ATPROTO_DECLARED_SCOPE, eo as APP_STATEMENT_LIMITS, fa as parseVoiceMeta, ft as ATPROTO_FULL_SCOPE, g as assembleAppBundle, gc as seedSigner, gi as domainTxtRecord, gt as atprotoProofRecord, hi as dnsProofName, ht as atprotoDidMethod, il as toZ32, it as parseSshSignature, jr as TYPING_KINDS, jt as didGhostlyServiceEntry, kn as decodeBolt11, ko as LIMITS, kr as transferEnded, kt as checkDidJws, la as VOICE_LIMITS, lo as signAppRevocation, lt as BitcoinAddressError, mi as decodeDnsResponse, mt as ATPROTO_PROOF_SCOPE, n as appStoreDecision, nl as randomBytes$1, no as appRef, nt as SshSigError, oa as sanitizeFileName, ol as utf8Encode, on as WALLET_NETWORKS, ot as sshSignCommand, pa as voicePeaksOf, pi as DOMAIN_FILE_MAX_BYTES, pt as ATPROTO_PROOF_COLLECTION, qn as fetchesByItself, ra as readImageMeta, rl as toBase64Url, ro as checkAppRevokeStatement, rt as parseSshPublicKey, s as checkAppStoreIndex, sa as sanitizeMime, so as readAppRevocations, st as verifySshSignature, ti as BUTTONS_CAPABILITY, tl as fromBase64Url$1, to as appFingerprint, tt as SSHSIG_NAMESPACE, u as signAppStore, ua as baseMime, uo as canonicalJson, ut as decodeAnyBitcoinAddress, v as isAppUrl, vi as encodeDnsQuery, vn as isPubkyKey, vt as checkAtprotoProofRecord, wi as recordsName, wn as pubkyProofPath, wt as verifyAtprotoRecordProof, xi as normalizeDomain, xn as normalizePubkyKey, xt as parseAtprotoDidDocument, y as readAppBundle, yi as isPublicAddress, yn as isPubkyProofFolder, yt as isAtprotoDid, za as PR_STATES, zi as identityStatement, zo as parseCallSignal, zt as normalizeDid } from "./assets/src-XzcHzneo.js";
+import { $n as readGroupHave, An as resolveLightningDestination, At as DidError, Ba as PR_CHECKS, Bo as extractParamsFromSdp, Bt as didWebHost, Ci as normalizeDomain, Cn as normalizePubkyKey, Ct as parseAtprotoDidDocument, Di as txtValue, Dn as homeserverWebEndpoint, Do as GhostlyHttpError, Dt as DID_DOCUMENT_MAX_BYTES$1, Ei as recordsName, En as pubkyProofPath, Et as verifyAtprotoRecordProof, Fo as RTC_CONFIG, Ft as didSignedMessages, Ga as cardLine, Gn as GROUP_FILE_LIMITS, Gt as signingKeys, Ha as RUN_RESULTS, Ho as signalHasVideo, Ht as parseDid, Ii as IdentityCheckUnavailable, Io as answersOffer, Ir as sanitizeTypingStatus, It as didWebDocumentUrl, Jn as GROUP_WANT_NO_FRAME, Ka as cardUrl, Kn as GROUP_HAVE_FRAME, Kt as staticDidDocument, La as replySnippet, Lo as buildSdpFromSignal, Lt as didWebFile, Mt as checkDidSignature, Nr as TYPING_KINDS, Nt as didGhostlyServiceEntry, Oi as wellKnownUrl, On as pubkyHomeserverOf, Ot as DID_FILE_MAX_BYTES, Po as CALL_SIGNAL_MAX_AGE_MS, Pr as TYPING_REFRESH_MS, Pt as didJwsAlg, Qi as irohRelayUrl, Qr as checkPushEndpoint, Qt as resolveDidDht, Ri as boundVerifiedIdentity, Ro as callRtcConfig, Rt as didWebFileNames, Si as nip05RootKey, Sn as newPubkyProofFolder, St as normalizeAtprotoHandle, Ti as recordsFromWellKnown, Tn as pubkyProofFile, Tt as AtprotoProofError, Ua as STATUS_CARD_LIMITS, Un as engineError, Ut as parseDidDocument, Va as PR_STATES, Vc as setLinkTraceSink, Vi as identityStatement, Vo as parseCallSignal, Vt as normalizeDid, Wa as buttonLabelClash, Wn as engineText, Wt as parseDidSignaturePaste, Xc as openRelayPayload, Xn as groupFileFallback, Yn as fetchesByItself, Zi as irohDescriptor, Zn as isGroupMessageId, _ as checkAppManifest, _i as dnsProofName, _t as atprotoDidMethod, aa as readImageMeta, ao as checkAppRevokeStatement, at as parseSshPublicKey, bi as encodeDnsQuery, bn as isPubkyKey, bt as checkAtprotoProofRecord, c as readAppStore, ca as sanitizeFileName, cl as toBase64Url, cn as WALLET_NETWORKS, ct as sshSignCommand, d as APP_BUNDLE_LIMITS, da as VOICE_LIMITS, dl as utf8Encode, do as signAppRevocation, dt as BitcoinAddressError, er as readGroupWant, fa as baseMime, fo as canonicalJson, ft as decodeAnyBitcoinAddress, g as assembleAppBundle, gi as decodeDnsResponse, gt as ATPROTO_PROOF_SCOPE, ha as voicePeaksOf, hi as DOMAIN_FILE_MAX_BYTES, ht as ATPROTO_PROOF_COLLECTION, il as sanitizeAvatar, io as appRef, it as SshSigError, jn as decodeBolt11, jo as LIMITS, jr as transferEnded, jt as checkDidJws, kn as requestLnurlInvoice, kr as ChatFiles, la as sanitizeMime, ll as toZ32, lo as readAppRevocations, lt as verifySshSignature, ma as parseVoiceMeta, mt as ATPROTO_FULL_SCOPE, n as appStoreDecision, no as APP_STATEMENT_LIMITS, ol as fromBase64Url$1, ot as parseSshSignature, pa as fileMessageText, pn as walletNetworkOf, po as canonicalJsonBytes, pt as ATPROTO_DECLARED_SCOPE, qa as checkStatusCard, qc as RELAY_PAYLOAD_MAX_BYTES, qt as strictBase64Url, ri as BUTTONS_CAPABILITY, rl as MAX_AVATAR_LENGTH, ro as appFingerprint, rt as SSHSIG_NAMESPACE, s as checkAppStoreIndex, sc as inviteLink, sl as randomBytes$1, st as sameSshKey, to as APP_PREFIXES, tr as readGroupWantNo, tt as groupName, u as signAppStore, ua as PLAYABLE_AUDIO, ul as utf8Decode, uo as signAppObject, ut as verifyBitcoinMessage, v as isAppUrl, vc as seedSigner, vi as domainTxtRecord, vt as atprotoProofRecord, wi as recordsFromTxt, wn as pubkyProofCapability, wt as shortAtprotoDid, xi as isPublicAddress, xn as isPubkyProofFolder, xt as isAtprotoDid, y as readAppBundle, ya as RateWindow, yi as domainWellKnownFile, yn as PUBKY_PROOF_MAX_BYTES, yt as atprotoProofRkey, za as ITEM_STATES, zo as callSignalHeardAt, zt as didWebFileUrl } from "./assets/src-_FzJkeAJ.js";
 import { c as fileStore, f as store$1, i as STORES, m as wrap, o as databaseName, p as transact, u as openDb } from "./assets/idb-CTF6LF5B.js";
 import { a as fileBytesOf, i as fileBytes, l as FILE_BYTES_STEP } from "./assets/fileBytes-BcYZhNgF.js";
 import { createRequire } from "node:module";
 import { spawn } from "node:child_process";
 import { connect, createServer, isIP } from "node:net";
-import { appendFileSync, chmodSync, closeSync, existsSync, fsyncSync, lstatSync, mkdirSync, openAsBlob, openSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
+import { accessSync, appendFileSync, chmodSync, closeSync, constants, existsSync, fsyncSync, lstatSync, mkdirSync, openAsBlob, openSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
 import { ed25519 } from "@noble/curves/ed25519.js";
 import { sha256 } from "@noble/hashes/sha2.js";
 import { createBase58check } from "@scure/base";
 import { schnorr } from "@noble/curves/secp256k1.js";
 import { wordlist } from "@scure/bip39/wordlists/english.js";
-import { access, constants, link, mkdir, open, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { access, constants as constants$1, link, mkdir, open, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import { basename, dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { createHash, createPrivateKey, generateKeyPairSync, randomBytes, timingSafeEqual } from "node:crypto";
 import { decode, npubEncode } from "nostr-tools/nip19";
@@ -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.2.2",
+	version: "1.2.3",
 	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",
@@ -1323,7 +1323,7 @@ var GroupFileDesk = class {
 	}
 	/**
 	* An error when this group took as many announcements of mine as it takes in a minute, or as its members take from
-	* one member in `announceWindowMs` (past that they would get the text, not the file); null when one may go now.
+	* one member in `announceWindowMs` (past that they would not fetch the file by themselves); null when one may go now.
 	*/
 	mayAnnounce(groupId) {
 		const wait = Math.max(...this.sentPaces(groupId).map((pace) => pace.wait()));
@@ -1340,9 +1340,9 @@ var GroupFileDesk = class {
 		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.
+	* A message of the group announces a file (mine, or a member's): the file its row shows. A member's is kept here
+	* unfetched, and fetched now when it is one this device takes by itself and the member announced no more than the
+	* group fetches that way. 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}`);
@@ -1384,9 +1384,9 @@ var GroupFileDesk = class {
 			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 paced = this.pace(this.takenPace, `${groupId}\n${m.sender}`, GROUP_FILE_LIMITS.announceTaken, GROUP_FILE_LIMITS.announceWindowMs).take();
 		const id = groupFileId(groupId, "in");
-		const auto = this.deps.settings().autoDownloads && fetchesByItself(m.file, this.keptAutomatically(groupId));
+		const auto = paced && 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 = {
@@ -2700,7 +2700,7 @@ var FILE_METHODS = {
 			throw new CliError("not_found", `No file ${path}`);
 		}
 		if (!info.isFile()) throw new CliError("bad_request", `${path} is not a file`);
-		await access(path, constants.R_OK);
+		await access(path, constants$1.R_OK);
 		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");
@@ -6172,7 +6172,8 @@ async function verifyIdToken(token, options) {
 }
 //#endregion
 //#region ../browser/src/proofs/oidc/flow.ts
-var STATE = /^(?:d\.\d{1,5}\.)?[A-Za-z0-9_-]{43}$/;
+/** Optional platform prefix (desktop `d.<port>.`, Android deep link `a.`), then 32 random bytes. */
+var STATE = /^(?:d\.\d{1,5}\.|a\.)?[A-Za-z0-9_-]{43}$/;
 function scopeFor$1(provider, reveal) {
 	const scopes = provider.id === "apple" ? [] : ["openid"];
 	const claims = [];
@@ -8727,13 +8728,15 @@ var IDENTITY_METHODS = {
 	},
 	async "identity.cancel"(ctx, params) {
 		const draftId = str(params, "draft", true);
-		drafts.delete(draftId);
+		if (!drafts.delete(draftId)) throw new CliError("not_found", "No such draft here: it is kept by the daemon that made it, for an hour");
 		await node(ctx).cancelIdentityProof({ draftId });
 		return { cancelled: draftId };
 	},
 	async "identity.remove"(ctx, params) {
-		await node(ctx).removeIdentityProof({ id: str(params, "id", true) });
-		return { removed: str(params, "id", true) };
+		const id = str(params, "id", true);
+		if (!state(ctx).identityProofs.some((p) => p.id === id)) throw new CliError("not_found", `No identity proof ${JSON.stringify(id)} (ghostly identity list)`);
+		await node(ctx).removeIdentityProof({ id });
+		return { removed: id };
 	},
 	async "identity.share"(ctx, params) {
 		const link = chatOf(ctx, params);
@@ -8748,13 +8751,15 @@ var IDENTITY_METHODS = {
 	},
 	async "identity.withdraw"(ctx, params) {
 		const link = chatOf(ctx, params);
+		const id = str(params, "id", true);
+		if (!link.identities?.shared.some((s) => s.id === id)) throw new CliError("not_found", `No identity proof ${JSON.stringify(id)} shared in this chat (ghostly identity contact ${link.id})`);
 		await node(ctx).withdrawIdentityProof({
 			linkId: link.id,
-			id: str(params, "id", true)
+			id
 		});
 		return {
 			chat: link.id,
-			withdrawn: str(params, "id", true)
+			withdrawn: id
 		};
 	},
 	/** What a contact shared in a chat, as this device checked it, and what this side shares there. */
@@ -8990,6 +8995,15 @@ async function proxy(request, response, chunks, send, cookies) {
 		plain(response, gone ? 503 : 502, gone ? "This service is not reachable. Services exist while their ghost is online." : `The request failed: ${error instanceof Error ? error.message : String(error)}`);
 	}
 }
+/**
+* The service a command names, by its id: one of this profile's. The engine changes nothing for an id it does not
+* know and says nothing, so a mistyped id read as done ("shared": true, with a contact).
+*/
+function serviceOf(ctx, params) {
+	const serviceId = str(params, "service", true);
+	if (!state(ctx).services.some((s) => s.id === serviceId)) throw new CliError("not_found", `No service ${JSON.stringify(serviceId)} (ghostly service list)`);
+	return serviceId;
+}
 var SERVICE_METHODS = {
 	async "service.list"(ctx) {
 		return { services: state(ctx).services.map((s) => ({
@@ -9016,29 +9030,32 @@ var SERVICE_METHODS = {
 		});
 	},
 	async "service.remove"(ctx, params) {
-		await node(ctx).removeService({ serviceId: str(params, "service", true) });
-		return { removed: str(params, "service", true) };
+		const serviceId = serviceOf(ctx, params);
+		await node(ctx).removeService({ serviceId });
+		return { removed: serviceId };
 	},
 	async "service.enable"(ctx, params) {
+		const serviceId = serviceOf(ctx, params);
 		await node(ctx).setServiceEnabled({
-			serviceId: str(params, "service", true),
+			serviceId,
 			enabled: !bool(params, "off")
 		});
 		return {
-			service: str(params, "service", true),
+			service: serviceId,
 			enabled: !bool(params, "off")
 		};
 	},
 	async "service.share"(ctx, params) {
 		const link = chatOf(ctx, params);
 		const shared = !bool(params, "off");
+		const serviceId = serviceOf(ctx, params);
 		await node(ctx).setServiceShared({
-			serviceId: str(params, "service", true),
+			serviceId,
 			peerPubKeyZ32: link.peerPubKeyZ32,
 			shared
 		});
 		return {
-			service: str(params, "service", true),
+			service: serviceId,
 			chat: link.id,
 			shared
 		};
@@ -13082,13 +13099,15 @@ var METHODS = {
 	},
 	async "chat.retry"(ctx, params) {
 		const link = chatOf(ctx, params);
+		const messageId = str(params, "message", true);
+		if (!await node(ctx).getMessage(link.id, messageId)) throw new CliError("not_found", `No message ${messageId} in this chat`);
 		await node(ctx).retryMessage({
 			linkId: link.id,
-			messageId: str(params, "message", true)
+			messageId
 		});
 		return {
 			chat: link.id,
-			messageId: params.message
+			messageId
 		};
 	},
 	async "chat.delete"(ctx, params) {
@@ -17350,6 +17369,14 @@ var refuseAnswers = Number(process.env.GHOSTLY_CALL_REFUSE_ANSWERS) || 0;
 var GATHER_MS = 5e3;
 var SETTLE_MS = 400;
 /**
+* With a candidate in (a host one comes in milliseconds), the server reflexive one is waited for this long at most,
+* not the whole of `GATHER_MS`: a STUN server that answers does in tens of milliseconds, and one that never does (UDP
+* to it blocked, as on many office, school and hotel networks) made every call ring 5 s late and connect 5 s after
+* the answer. The apps' calls and the chats' data link bound theirs the same way (`HOST_GATHER_MS`,
+* `OFFER_HOST_GATHER_MS`).
+*/
+var HOST_GATHER_MS = 2e3;
+/**
 * One call's peer connection. Its SDP never travels: the compact signal does (`local`), and each side rebuilds the
 * other's SDP from it (`buildSdpFromSignal`), so the payload types, SSRC and mids here are the ones that rebuilt SDP
 * uses: audio is mid 0, Opus is 111 unless the contact's offer says otherwise.
@@ -17421,7 +17448,7 @@ var CallMedia = class CallMedia {
 			const track = pc.addTrack(audioSection);
 			let videoTrack = null;
 			if (offer?.m?.includes("v")) {
-				const video = new ndc.Video(String(offer.m.indexOf("v")), "RecvOnly");
+				const video = new ndc.Video(String(offer.m.indexOf("v")), "Inactive");
 				video.addVP8Codec(offer.vp ?? 96);
 				videoTrack = pc.addTrack(video);
 				videoTrack.onMessage(() => {});
@@ -17440,6 +17467,7 @@ var CallMedia = class CallMedia {
 				ss: [ssrc]
 			};
 			if (offer?.m) local.m = [...offer.m];
+			if (videoTrack) local.vr = 0;
 			const listeners = [];
 			track.onMessage((packet) => {
 				for (const listener of listeners) listener(packet);
@@ -17520,20 +17548,26 @@ function mdnsNote(signal, log) {
 		lookup(host, { all: true }).then((found) => log(`${host} resolves here to ${found.map((a) => a.address).join(", ")}`), () => log(`${host} does not resolve here: the call connects only if the contact's checks reach this side`));
 	}
 }
-/** Resolves once the local description has its candidates (see GATHER_MS). */
+/** Resolves once the local description has its candidates (see GATHER_MS and HOST_GATHER_MS). */
 function gathering(pc) {
 	return new Promise((resolve) => {
 		let settle = null;
+		let any = false;
 		const done = () => {
 			clearTimeout(cap);
+			clearTimeout(bounded);
 			if (settle) clearTimeout(settle);
 			resolve();
 		};
 		const cap = setTimeout(done, GATHER_MS);
+		const bounded = setTimeout(() => {
+			if (any) done();
+		}, HOST_GATHER_MS);
 		pc.onGatheringStateChange((state) => {
 			if (state === "complete") done();
 		});
 		pc.onLocalCandidate((candidate) => {
+			any = true;
 			if (!settle && / typ srflx/.test(candidate)) settle = setTimeout(done, SETTLE_MS);
 		});
 	});
@@ -18189,23 +18223,15 @@ var EventHub = class {
 			request.onsuccess = () => resolve(request.result);
 			request.onerror = () => reject(request.error);
 		});
-		const rows = await new Promise((resolve, reject) => {
-			const out = [];
-			const request = this.db.transaction(SEEN).objectStore(SEEN).openCursor();
-			request.onsuccess = () => {
-				const cursor = request.result;
-				if (!cursor) return resolve(out);
-				out.push({
-					key: cursor.key,
-					value: cursor.value
-				});
-				cursor.continue();
-			};
+		const store = this.db.transaction(SEEN).objectStore(SEEN);
+		const all = (request) => new Promise((resolve, reject) => {
+			request.onsuccess = () => resolve(request.result);
 			request.onerror = () => reject(request.error);
 		});
-		for (const { key, value } of rows) {
-			const [chat, id] = key;
-			this.seenOf(chat).set(id, value);
+		const [keys, values] = await Promise.all([all(store.getAllKeys()), all(store.getAll())]);
+		for (let i = 0; i < keys.length; i++) {
+			const [chat, id] = keys[i];
+			this.seenOf(chat).set(id, values[i]);
 		}
 		this.mentionsNoted = this.firstRun || this.seen.get(FORMAT)?.get(MENTIONS_NOTED) === "yes";
 	}
@@ -18691,8 +18717,13 @@ var EventHub = class {
 		}
 		if (changes.length) this.persist(key, changes);
 	}
+	/**
+	* Relaxed: nobody waits for it, and a note lost to a power cut is made again from the history at the next start
+	* (its event is then reported a second time, as after a crash between a message's row and its note). A disk sync
+	* for each one held the whole daemon for milliseconds, three times per message sent.
+	*/
 	persist(chat, changes) {
-		const store = this.db.transaction(SEEN, "readwrite").objectStore(SEEN);
+		const store = this.db.transaction(SEEN, "readwrite", { durability: "relaxed" }).objectStore(SEEN);
 		for (const [id, state] of changes) if (state === null) store.delete([chat, id]);
 		else store.put(state, [chat, id]);
 	}
@@ -19067,7 +19098,7 @@ function federationInfo(federationId, config) {
 	};
 }
 /** The first value a subscription gives that is final, or the last one within `waitMs`. */
-function watch(subscribe, final, waitMs) {
+function watch$1(subscribe, final, waitMs) {
 	return new Promise((resolve) => {
 		let last, done = false, cancel = () => {};
 		const finish = () => {
@@ -19138,13 +19169,13 @@ var RealClient = class {
 		return this.wallet.mint.tryCancelSpendNotes(operationId);
 	}
 	spendState(operationId, waitMs) {
-		return watch((ok, fail) => this.wallet.mint.subscribeSpendNotes(operationId, (s) => ok(SPEND[s] ?? "created"), fail), spendFinal, waitMs);
+		return watch$1((ok, fail) => this.wallet.mint.subscribeSpendNotes(operationId, (s) => ok(SPEND[s] ?? "created"), fail), spendFinal, waitMs);
 	}
 	redeem(notes, ghostly) {
 		return this.wallet.mint.reissueExternalNotes(notes, { ghostly });
 	}
 	redeemState(operationId, waitMs) {
-		return watch((ok, fail) => this.wallet.mint.subscribeReissueExternalNotes(operationId, (s) => ok(typeof s === "string" ? REDEEM[s] ?? "created" : s && typeof s === "object" && "Failed" in s ? "failed" : "created"), (error) => {
+		return watch$1((ok, fail) => this.wallet.mint.subscribeReissueExternalNotes(operationId, (s) => ok(typeof s === "string" ? REDEEM[s] ?? "created" : s && typeof s === "object" && "Failed" in s ? "failed" : "created"), (error) => {
 			ok("failed");
 			fail(error);
 		}), (s) => s === "done" || s === "failed", waitMs);
@@ -19157,7 +19188,7 @@ var RealClient = class {
 		};
 	}
 	receiveState(operationId, waitMs) {
-		return watch((ok, fail) => this.wallet.lightning.subscribeLnReceive(operationId, (s) => ok(receiveOf(s)), fail), (s) => s === "claimed" || s === "canceled", waitMs);
+		return watch$1((ok, fail) => this.wallet.lightning.subscribeLnReceive(operationId, (s) => ok(receiveOf(s)), fail), (s) => s === "claimed" || s === "canceled", waitMs);
 	}
 	async gatewayFee(amountMsats) {
 		await this.wallet.lightning.updateGatewayCache().catch(() => {});
@@ -19175,7 +19206,7 @@ var RealClient = class {
 		};
 	}
 	async payState(operationId, internal, waitMs) {
-		const state = await watch((ok, fail) => internal ? this.wallet.lightning.subscribeInternalPayment(operationId, ok, fail) : this.wallet.lightning.subscribeLnPay(operationId, ok, fail), (s) => typeof s === "object" && !!s && ("success" in s || "preimage" in s || "refunded" in s || "refund_success" in s || "unexpected_error" in s || "funding_failed" in s) || s === "canceled", waitMs);
+		const state = await watch$1((ok, fail) => internal ? this.wallet.lightning.subscribeInternalPayment(operationId, ok, fail) : this.wallet.lightning.subscribeLnPay(operationId, ok, fail), (s) => typeof s === "object" && !!s && ("success" in s || "preimage" in s || "refunded" in s || "refund_success" in s || "unexpected_error" in s || "funding_failed" in s) || s === "canceled", waitMs);
 		if (state && typeof state === "object") {
 			const s = state;
 			if (s.success?.preimage || s.preimage) return {
@@ -19510,6 +19541,10 @@ var SNAPSHOT = "snapshot.bin";
 var JOURNAL = "journal.bin";
 /** A journal past this is folded into the snapshot at the next quiet moment. */
 var COMPACT_BYTES = 33554432;
+/** How long `close` waits for the transactions still running: one left open for good does not keep the process. */
+var CLOSE_WAIT_MS = 5e3;
+/** How long a relaxed transaction's entry may wait for a sync when no other transaction brings one. */
+var RELAXED_SYNC_MS = 1e3;
 var BLOB = "__ghostlyBlob";
 var RANGE = "__ghostlyRange";
 var PROBE = "__ghostly_storage_probe__";
@@ -19532,12 +19567,14 @@ async function openPersistentIndexedDb(dir) {
 	let queue = Promise.resolve();
 	let queued = 0;
 	let schemaDirty = false;
+	/** Set while the journal holds relaxed entries no sync has covered yet. */
+	let relaxed = null;
 	const pending = /* @__PURE__ */ new WeakMap();
 	const snapshotPath = join(dir, SNAPSHOT);
 	const journalPath = join(dir, JOURNAL);
 	const snapshotFound = existsSync(snapshotPath), journalFound = existsSync(journalPath);
-	if (snapshotFound) restore(classes, raw._databases, deserialize(readFileSync(snapshotPath)), (a, b) => factory.cmp(a, b));
-	if (journalFound) replay(raw._databases, readFileSync(journalPath));
+	if (snapshotFound) restore(classes, raw._databases, deserialize(readFileSync(snapshotPath)), keyOrder((a, b) => factory.cmp(a, b)));
+	if (journalFound) replay(raw._databases, readFileSync(journalPath), keyOrder((a, b) => factory.cmp(a, b)));
 	restoring = false;
 	if (journalFound || !snapshotFound) await writeSnapshot();
 	const storeProto = classes.ObjectStore.prototype;
@@ -19584,7 +19621,7 @@ async function openPersistentIndexedDb(dir) {
 			if (this.mode === "versionchange") schemaDirty = true;
 			else {
 				const ops = pending.get(this._rollbackLog);
-				if (ops?.length) append(ops);
+				if (ops?.length) append(ops, this.durability === "relaxed");
 			}
 			pending.delete(this._rollbackLog);
 			if (schemaDirty) enqueue(writeSnapshot);
@@ -19606,34 +19643,54 @@ async function openPersistentIndexedDb(dir) {
 		});
 		return request;
 	};
-	function append(ops) {
+	function append(ops, lazy) {
 		if (queued === 0 && !ops.some((op) => op.kind === "put" && hasBlob(op.value))) {
-			writeEntry(serialize(ops));
+			writeEntry(serialize(ops), lazy);
 			return;
 		}
 		enqueue(async () => writeEntry(serialize(await Promise.all(ops.map(async (op) => op.kind === "put" ? {
 			...op,
 			value: await blobsToDisk(op.value)
-		} : op)))));
+		} : op))), lazy));
 	}
 	function enqueue(work) {
 		queued++;
-		queue = queue.then(work).catch((error) => {
-			process.stderr.write(`ghostly: storage write failed: ${error instanceof Error ? error.message : String(error)}\n`);
-		}).finally(() => {
+		queue = queue.then(work).catch(failed).finally(() => {
 			queued--;
 		});
 		return queue;
 	}
-	function writeEntry(entry) {
+	function failed(error) {
+		process.stderr.write(`ghostly: storage write failed: ${error instanceof Error ? error.message : String(error)}\n`);
+	}
+	/**
+	* `lazy`: a relaxed transaction's entry. A sync blocks the whole process for milliseconds, and what such a
+	* transaction wrote can be made again (the event set's note of a message it already reported): written, it outlives
+	* the process; a power cut may take its last second.
+	*/
+	function writeEntry(entry, lazy = false) {
 		if (!writing) return;
 		journalFd ??= openSync(journalPath, "a", 384);
 		const header = Buffer.alloc(4);
 		header.writeUInt32BE(entry.length);
 		writeSync(journalFd, Buffer.concat([header, entry]));
-		fsyncSync(journalFd);
+		if (lazy) relaxed ??= setTimeout(() => {
+			try {
+				sync();
+			} catch (error) {
+				failed(error);
+			}
+		}, RELAXED_SYNC_MS).unref();
+		else sync();
 		if (statSync(journalPath).size > COMPACT_BYTES) enqueue(writeSnapshot);
 	}
+	function sync() {
+		if (relaxed) {
+			clearTimeout(relaxed);
+			relaxed = null;
+		}
+		if (journalFd !== null) fsyncSync(journalFd);
+	}
 	async function writeSnapshot() {
 		schemaDirty = false;
 		const snapshot = {
@@ -19676,12 +19733,29 @@ async function openPersistentIndexedDb(dir) {
 			closeSync(fd);
 		}
 		renameSync(temporary, snapshotPath);
+		if (relaxed) {
+			clearTimeout(relaxed);
+			relaxed = null;
+		}
 		if (journalFd !== null) {
 			closeSync(journalFd);
 			journalFd = null;
 		}
 		rmSync(journalPath, { force: true });
 	}
+	/**
+	* Resolves once no transaction is left to run. The engine does not wait for every write (`void db.deleteLink(…)`),
+	* and fake-indexeddb runs a transaction on a later turn of the event loop: a command that closed in the turn it wrote
+	* in (no chat to say goodbye to) took its last snapshot before the write, and answered done for what was not on disk.
+	* Two quiet turns in a row: a write that begins when another ends (a chat's messages after its row) is seen too.
+	*/
+	async function settled() {
+		const until = Date.now() + CLOSE_WAIT_MS;
+		for (let quiet = 0; quiet < 2 && Date.now() < until;) {
+			await new Promise((resolve) => setImmediate(resolve));
+			quiet = [...raw._databases.values()].some((db) => db.transactions.some((transaction) => transaction._state !== "finished")) ? 0 : quiet + 1;
+		}
+	}
 	const installed = globalThis;
 	installed.indexedDB = factory;
 	installed.IDBKeyRange = IDBKeyRange$1;
@@ -19690,6 +19764,7 @@ async function openPersistentIndexedDb(dir) {
 		flush: () => queue,
 		compact: () => enqueue(writeSnapshot),
 		async close() {
+			await settled();
 			await enqueue(writeSnapshot);
 			writing = false;
 			if (journalFd !== null) {
@@ -19781,17 +19856,49 @@ function dropIndexEntriesByRecord(classes, cmp) {
 			for (const candidate of gone.indexes.values()) if (candidate.records === this) index = candidate;
 		}
 		if (!gone || !index) return deleteByValue.call(this, key);
-		const dropped = [];
-		for (const entry of indexEntries(index, gone.records, cmp)) {
-			if (this.keysAreUnique) {
-				const held = this.get(entry.key);
-				if (!held || cmp(held.value, entry.value) !== 0) continue;
+		return dropEntries(index, gone.records, cmp);
+	};
+}
+/** Drops from an index the entries of records that left its store, and gives back the ones it dropped. */
+function dropEntries(index, records, cmp) {
+	const dropped = [];
+	for (const entry of indexEntries(index, records, cmp)) {
+		if (index.records.keysAreUnique) {
+			const held = index.records.get(entry.key);
+			if (!held || cmp(held.value, entry.value) !== 0) continue;
+		}
+		index.records.records.delete(entry);
+		dropped.push(entry);
+	}
+	return dropped;
+}
+/**
+* `cmp` for keys that are stored already (a record's, an index entry's): numbers, strings and arrays of them are
+* ordered here, as IndexedDB orders them (a number before a string before an array; strings by code unit; arrays item
+* by item, then the shorter first). Anything else (a date, bytes, a value that is no key) is left to `cmp`, which
+* checks and copies both keys at every call: on the way back from a snapshot that was a third of a large store's time.
+*/
+function keyOrder(cmp) {
+	const order = (a, b) => {
+		const first = typeof a, second = typeof b;
+		if (first === "number" && second === "number") return a === b ? 0 : a > b ? 1 : a < b ? -1 : cmp(a, b);
+		if (first === "string" && second === "string") return a === b ? 0 : a > b ? 1 : -1;
+		if (first === "number" && second === "string") return -1;
+		if (first === "string" && second === "number") return 1;
+		if (Array.isArray(a)) {
+			if (second === "number" || second === "string") return 1;
+			if (!Array.isArray(b)) return cmp(a, b);
+			const length = Math.min(a.length, b.length);
+			for (let at = 0; at < length; at++) {
+				const item = order(a[at], b[at]);
+				if (item !== 0) return item;
 			}
-			this.records.delete(entry);
-			dropped.push(entry);
+			return a.length === b.length ? 0 : a.length > b.length ? 1 : -1;
 		}
-		return dropped;
+		if (Array.isArray(b) && (first === "number" || first === "string")) return -1;
+		return cmp(a, b);
 	};
+	return order;
 }
 /**
 * The snapshot's records come in key order (as `writeSnapshot` walks them), so each store's tree and each index's are
@@ -19888,21 +19995,27 @@ function fill(store, sorted) {
 /**
 * Replays whole entries; a torn last entry (the process died mid-write) was never acknowledged and is dropped.
 *
-* A store's indexes are set aside while its ops replay and rebuilt once at the end: fake-indexeddb drops an
+* A store's indexes are set aside while its ops replay and brought in step once at the end: fake-indexeddb drops an
 * overwritten or deleted record from an index by walking every record of it, so a crash after a busy chat took
-* tens of seconds to minutes to start, one write at a time against the whole profile.
+* tens of seconds to minutes to start, one write at a time against the whole profile. Only the rows the journal
+* touched change in an index (what each was before goes, what it is now comes in): a journal of one message costs one
+* message, not the profile's history once per index. A store the journal cleared has its indexes built again whole.
 */
-function replay(databases, journal) {
+function replay(databases, journal, cmp) {
 	const touched = /* @__PURE__ */ new Map();
 	try {
 		replayEntries(databases, journal, touched);
 	} finally {
-		for (const [store, indexes] of touched) {
+		for (const [store, { indexes, was, now }] of touched) {
+			const records = store.records;
+			delete records.put;
+			delete records.delete;
 			store.rawIndexes = indexes;
 			for (const index of indexes.values()) {
-				index.records.clear();
+				if (!was) index.records.clear();
 				if (!index.initialized) continue;
-				for (const record of store.records.values()) index.storeRecord(record);
+				if (was) dropEntries(index, [...was], cmp);
+				for (const record of was ? now : store.records.values()) if (!absent(index.keyPath, record.value)) index.storeRecord(record);
 			}
 		}
 	}
@@ -19922,19 +20035,50 @@ function replayEntries(databases, journal, touched) {
 		for (const op of ops) {
 			const store = databases.get(op.db)?.rawObjectStores.get(op.store);
 			if (!store) continue;
-			if (!touched.has(store)) {
-				touched.set(store, store.rawIndexes);
-				store.rawIndexes = /* @__PURE__ */ new Map();
-			}
+			let change = touched.get(store);
+			if (!change) touched.set(store, change = watch(store));
 			if (op.kind === "put") store.storeRecord({
 				key: op.key,
 				value: blobsFromDisk(op.value)
 			}, false);
 			else if (op.kind === "delete") store.deleteRecord(keyFromDisk(op.key));
-			else store.clear();
+			else {
+				change.was = null;
+				store.clear();
+			}
 		}
 	}
 }
+/**
+* Sets a store's indexes aside and notes, as its records are written over and removed, which ones left and which
+* ones came: the record store hands back what a put replaced and what a delete removed, so a row costs no lookup.
+* A record that came and left again was never in an index.
+*/
+function watch(store) {
+	const change = {
+		indexes: store.rawIndexes,
+		was: store.rawIndexes.size ? /* @__PURE__ */ new Set() : null,
+		now: /* @__PURE__ */ new Set()
+	};
+	store.rawIndexes = /* @__PURE__ */ new Map();
+	if (!change.was) return change;
+	const { put, delete: remove } = store.records;
+	const left = (record) => {
+		if (!change.now.delete(record)) change.was?.add(record);
+	};
+	store.records.put = (next, keep) => {
+		const replaced = put.call(store.records, next, keep);
+		if (replaced) left(replaced);
+		change.now.add(next);
+		return replaced;
+	};
+	store.records.delete = (key) => {
+		const removed = remove.call(store.records, key);
+		removed.forEach(left);
+		return removed;
+	};
+	return change;
+}
 function keyToDisk(key) {
 	if (key instanceof IDBKeyRange$1) return { [RANGE]: {
 		lower: key.lower,
@@ -20188,14 +20332,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-BcYZhNgF.js").then((n) => n.o), import("./assets/fileBytes-Dbifu5I5.js")]);
 	registerFileBytes("native", async () => new NodeFileBytes(paths.files), true);
-	const [{ EngineServer }, { createHyperEndpoint }] = await Promise.all([import("./assets/server-Cy4ox7oD.js").then((n) => n.t), import("./assets/endpoint-pgFkR2AS.js")]);
+	const [{ EngineServer }, { createHyperEndpoint }] = await Promise.all([import("./assets/server-DHMXMwNn.js").then((n) => n.t), import("./assets/endpoint-pgFkR2AS.js")]);
 	const network = hyperdhtNetwork();
 	const dht = mainlineNetwork();
-	const mainline = dht.off ? null : new (await (import("./assets/mainline-1v8OTYvp.js"))).Mainline({
+	const mainline = dht.off ? null : new (await (import("./assets/mainline-DriRu_hb.js"))).Mainline({
 		bootstrap: dht.bootstrap,
 		host: dht.host
 	});
-	const transport = mainline || pinned ? new (await (import("./assets/mainline-1v8OTYvp.js"))).RelaysAndDht(mainline, pinned ? { relays: pinned } : {}, !!pinned) : null;
+	const transport = mainline || pinned ? new (await (import("./assets/mainline-DriRu_hb.js"))).RelaysAndDht(mainline, pinned ? { relays: pinned } : {}, !!pinned) : null;
 	const server = new EngineServer({
 		...transport ? { transport } : {},
 		irohWeb: true,
@@ -20340,10 +20484,14 @@ var guarded = false;
 /**
 * A daemon says an error nobody caught (with its stack, on stderr: the daemon's log when detached) and keeps serving:
 * one request gone wrong must not take the profile offline. One-shot commands do not call this; they still fail loudly.
+*
+* `outputs`: what it writes to. A write there that fails (a pipe whose reader is gone: the process that started the
+* daemon died) is dropped, not an error nobody caught: saying it would be one more failed write, and the next, with
+* no turn left for anything else (a full core, and no stop on SIGTERM).
 */
 function keepServing(proc = process, write = (text) => {
 	process.stderr.write(text);
-}) {
+}, outputs = proc === process ? [process.stdout, process.stderr] : []) {
 	if (proc === process) {
 		if (guarded) return;
 		guarded = true;
@@ -20353,6 +20501,7 @@ function keepServing(proc = process, write = (text) => {
 			write(`ghostly: ${what}, the daemon keeps serving: ${error instanceof Error ? error.stack ?? error.message : String(error)}\n`);
 		} catch {}
 	};
+	for (const output of outputs) output.on("error", () => {});
 	proc.on("unhandledRejection", log("unhandled rejection"));
 	proc.on("uncaughtException", log("uncaught exception"));
 }
@@ -20556,6 +20705,18 @@ function readCursor(path) {
 	const value = Number(readFileSync(path, "utf8").trim());
 	return Number.isInteger(value) && value >= 0 ? value : void 0;
 }
+/**
+* Whether a cursor can be kept at `path`, asked before anything starts: its folder is there and takes a file. Before, a
+* folder that was not there was found at the first event: the listener ran, said "event N failed: ENOENT" for each one
+* and never wrote the cursor, so the next start began at the journal's end and skipped what came while it was down.
+* Throws what the file system says (`asCliError` names the path and the code: not_found, refused).
+*/
+function checkCursor(path) {
+	if (!path) return;
+	const folder = dirname(resolve(path));
+	if (!statSync(folder).isDirectory()) throw new CliError("not_found", `No such file or folder: ${folder}`);
+	accessSync(folder, constants.W_OK | constants.X_OK);
+}
 function writeCursor(path, seq) {
 	rmSync(path + ".tmp", { force: true });
 	writeFileSync(path + ".tmp", String(seq) + "\n", {
@@ -21361,6 +21522,7 @@ async function listenCommand(argv) {
 			description: ""
 		}
 	});
+	noMoreThan(0, parsed.positionals, SPECIAL.find(([usage]) => usage.startsWith("listen "))[0]);
 	const g = globals(parsed);
 	pretty = false;
 	if (parsed.options.webhook) checkWebhook(String(parsed.options.webhook));
@@ -21369,6 +21531,7 @@ async function listenCommand(argv) {
 	if (turns && types.length) throw new CliError("usage", "--turns takes the place of --type: a turn is a message received, or a group message that mentions you");
 	const from = parsed.options.from ?? [], groups = parsed.options.group ?? [];
 	const cursor = parsed.options.cursor;
+	checkCursor(cursor);
 	let since = parsed.options.since ?? readCursor(cursor);
 	let handle = null;
 	const start = async (call, peerOf) => {