@ghostlytools/cli 1.1.4 → 1.1.5

package/dist/ghostly.mjs

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
-import { a as fileBytesOf, d as __exportAll, i as fileBytes, l as FILE_BYTES_STEP } from "./assets/fileBytes-DxiJHmTk.js";
-import { $ as checkAtprotoProofRecord, $i as replySnippet, $r as IdentityCheckUnavailable, $s as fromBase64Url$1, $t as isPubkyKey, Aa as CALL_SIGNAL_MAX_AGE_MS, Ai as parseVoiceMeta, B as sameSshKey, Bs as RELAY_PAYLOAD_MAX_BYTES, Ca as GhostlyHttpError, Cn as resolveLightningDestination, Ct as parseDidSignaturePaste, Da as LIMITS, Di as VOICE_LIMITS, Ei as PLAYABLE_AUDIO, En as decodeBolt11, Et as strictBase64Url, Fa as callSignalHeardAt, G as decodeAnyBitcoinAddress, H as verifySshSignature, I as SSHSIG_NAMESPACE, Ia as extractParamsFromSdp, Ir as BUTTONS_CAPABILITY, J as ATPROTO_PROOF_COLLECTION, K as ATPROTO_DECLARED_SCOPE, Kt as walletNetworkOf, L as SshSigError, La as parseCallSignal, Ma as answersOffer, Na as buildSdpFromSignal, Oi as baseMime, P as groupName, Pa as callRtcConfig, Pr as checkPushEndpoint, Ps as setLinkTraceSink, Q as atprotoProofRkey, Qt as PUBKY_PROOF_MAX_BYTES, R as parseSshPublicKey, Ra as signalHasVideo, Si as readImageMeta, Sn as requestLnurlInvoice, St as parseDidDocument, Ti as sanitizeMime, Tn as engineText, Tt as staticDidDocument, U as verifyBitcoinMessage, Us as openRelayPayload, V as sshSignCommand, Vt as WALLET_NETWORKS, W as BitcoinAddressError, X as atprotoDidMethod, Xs as MAX_AVATAR_LENGTH, Y as ATPROTO_PROOF_SCOPE, Z as atprotoProofRecord, Zs as sanitizeAvatar, _n as recordsFromTxt, _t as didWebFileNames, aa as checkStatusCard, an as pubkyProofPath, at as verifyAtprotoRecordProof, bn as txtValue, bt as normalizeDid, cn as DOMAIN_FILE_MAX_BYTES, dn as domainTxtRecord, dt as checkDidSignature, ec as randomBytes$1, en as isPubkyProofFolder, et as isAtprotoDid, fn as domainWellKnownFile, ft as didGhostlyServiceEntry, gn as normalizeDomain, gr as TYPING_REFRESH_MS, gt as didWebFile, hn as nip05RootKey, hr as TYPING_KINDS, ht as didWebDocumentUrl, ia as buttonLabelClash, ic as utf8Encode, ii as identityStatement, in as pubkyProofFile, it as AtprotoProofError, ja as RTC_CONFIG, ji as voicePeaksOf, jt as resolveDidDht, ln as decodeDnsResponse, lt as DidError, mn as isPublicAddress, mt as didSignedMessages, na as RUN_RESULTS, nn as normalizePubkyKey, nt as parseAtprotoDidDocument, on as homeserverWebEndpoint, ot as DID_DOCUMENT_MAX_BYTES$1, pn as encodeDnsQuery, pt as didJwsAlg, q as ATPROTO_FULL_SCOPE, ra as STATUS_CARD_LIMITS, rc as utf8Decode, rn as pubkyProofCapability, rs as inviteLink, rt as shortAtprotoDid, sn as pubkyHomeserverOf, st as DID_FILE_MAX_BYTES, ta as ITEM_STATES, tc as toBase64Url$1, ti as boundVerifiedIdentity, tn as newPubkyProofFolder, tt as normalizeAtprotoHandle, un as dnsProofName, ut as checkDidJws, vn as recordsFromWellKnown, vr as sanitizeTypingStatus, vt as didWebFileUrl, wi as sanitizeFileName, wn as engineError, wt as signingKeys, xn as wellKnownUrl, xt as parseDid, yn as recordsName, yt as didWebHost, z as parseSshSignature } from "./assets/src-K3NijMq-.js";
-import { d as wrap, i as databaseName, l as store$1, n as STORES, o as fileStore, s as openDb, u as transact } from "./assets/idb-Co2lObpU.js";
+import { t as __exportAll } from "./assets/rolldown-runtime-8H4AJuhK.js";
+import { $ as 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 { c as fileStore, d as store$1, f as transact, i as STORES, l as openDb, o as databaseName, p as wrap } from "./assets/idb-BIdus0WX.js";
+import { a as fileBytesOf, i as fileBytes, l as FILE_BYTES_STEP } from "./assets/fileBytes-3AQ2tJzW.js";
 import { createRequire } from "node:module";
 import { spawn } from "node:child_process";
 import { connect, createServer, isIP } from "node:net";
@@ -17,7 +18,7 @@ import { decode, npubEncode } from "nostr-tools/nip19";
 import { BunkerSigner } from "nostr-tools/nip46";
 import { SimplePool } from "nostr-tools/pool";
 import { generateSecretKey } from "nostr-tools/pure";
-import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
+import { createHash, createPrivateKey, generateKeyPairSync, randomBytes, timingSafeEqual } from "node:crypto";
 import { createServer as createServer$1 } from "node:http";
 import { Readable } from "node:stream";
 import { pipeline } from "node:stream/promises";
@@ -34,7 +35,7 @@ import { IDBFactory, IDBKeyRange as IDBKeyRange$1, IDBTransaction } from "fake-i
 import { format } from "node:util";
 var package_default = {
 	name: "@ghostlytools/cli",
-	version: "1.1.4",
+	version: "1.1.5",
 	type: "module",
 	description: "Ghostly for bots and terminals: the app's own engine, headless on Node, behind a daemon and a `ghostly` command with JSON output.",
 	license: "MIT",
@@ -595,6 +596,10 @@ var ENGINE_METHODS = [
 	"retryMessage",
 	"react",
 	"pinMessage",
+	"appId",
+	"appOpen",
+	"appClose",
+	"appSend",
 	"messageDetails",
 	"deleteMessage",
 	"exportLinks",
@@ -713,7 +718,27 @@ var ENGINE_METHODS = [
 	"deviceSetNoticeSeen",
 	"deviceTurnCheck",
 	"devicePushState",
-	"devicePushSet"
+	"devicePushSet",
+	"appList",
+	"appStoreList",
+	"appStorePreview",
+	"appStoreAdd",
+	"appStoreRemove",
+	"appStoreRefresh",
+	"appPreview",
+	"appInstall",
+	"appUpdateAccept",
+	"appCheckUpdates",
+	"appUninstall",
+	"appRunCheck",
+	"appFetchFiles",
+	"appEntry",
+	"appFile",
+	"appStorageGet",
+	"appStorageSet",
+	"appStorageDelete",
+	"appStorageKeys",
+	"appDataExport"
 ];
 /** Reads the hosts use outside `EngineApi`: the whole state, and one chat's stored messages. */
 var ENGINE_READS = ["getState", "getMessages"];
@@ -6248,7 +6273,7 @@ function openPassportWindow(url) {
 	return window.open(url, "pubky-passport", "popup,width=520,height=760");
 }
 /** A 401 or 403 from the homeserver: the session it was given is not one it accepts. */
-var refused = (e) => {
+var refused$1 = (e) => {
 	const status = e?.data?.statusCode;
 	return status === 401 || status === 403;
 };
@@ -6479,7 +6504,7 @@ async function approveAndWork(options, work, { grant, cookie, opened, settled, c
 		throw e;
 	}
 	const fail = (what) => (e) => {
-		if (viaCookie && !cookieKept && refused(e)) throw new Error("Pubky Ring approved, but this browser blocks your homeserver's sign-in cookie (Vanadium and Safari block cookies from other sites), so nothing was written. Approve with Pubky Passport instead, or use Firefox or the Ghostly desktop app.");
+		if (viaCookie && !cookieKept && refused$1(e)) throw new Error("Pubky Ring approved, but this browser blocks your homeserver's sign-in cookie (Vanadium and Safari block cookies from other sites), so nothing was written. Approve with Pubky Passport instead, or use Firefox or the Ghostly desktop app.");
 		throw failure(what, e);
 	};
 	const approved = session;
@@ -8489,7 +8514,7 @@ async function restoreProfile(home, name, file, passphrase) {
 		if (!reader) {
 			const payload = await readWhole(file, passphrase ?? "");
 			work = await restoringFolder(home, name);
-			await writeWhole(work, payload);
+			await writeWhole$1(work, payload);
 			return await finishRestore(home, name, work);
 		}
 		const next = async () => {
@@ -8582,7 +8607,7 @@ async function readWhole(file, passphrase) {
 	if (payload?.format !== FORMAT_1 || typeof payload.store !== "string" || !Array.isArray(payload.files)) throw new CliError("refused", "This backup is not a headless Ghostly profile");
 	return payload;
 }
-async function writeWhole(paths, payload) {
+async function writeWhole$1(paths, payload) {
 	await mkdir(paths.db, {
 		recursive: true,
 		mode: 448
@@ -12206,6 +12231,565 @@ function connectDaemon(path, timeoutMs = 2e3) {
 	});
 }
 //#endregion
+//#region src/apps.ts
+var APP_SOURCE = "ghostly-app.json";
+var APP_REVOKE_FILE = "ghostly-revoke.json";
+var STORE_INDEX_FILE = "ghostly-store.json";
+var STORE_SIG_FILE = "ghostly-store.sig";
+/** How long `app verify` waits for a URL, and how many redirects it follows (each checked as the first). */
+var FETCH_TIMEOUT_MS = 6e4;
+var MAX_REDIRECTS = 5;
+var KEY_HEADER = {
+	publisher: "Ghostly publisher key (WISP 1200). Secret: never share or commit it. Back it up: an app signed with it is updated only with it.",
+	store: "Ghostly store key (WISP 1200). Secret: keep it offline, never share or commit it. Back it up: a store is its key."
+};
+var PEM = /-----BEGIN PRIVATE KEY-----\r?\n([A-Za-z0-9+/=\r\n]+)-----END PRIVATE KEY-----/;
+/** Refuses a key file that is not a plain file of this user's, or that anyone else may read or write. */
+function checkKeyFile(path) {
+	const info = statSync(path);
+	if (!info.isFile()) throw new CliError("bad_request", `${path} is not a file: --key names a key file`);
+	if (process.platform === "win32") return;
+	if (process.getuid && info.uid !== process.getuid()) throw new CliError("refused", `${path} is not this user's: a key file must be yours alone`);
+	if ((info.mode & 63) !== 0) throw new CliError("refused", `${path} may be read by others (mode ${(info.mode & 511).toString(8)}): run chmod 600 ${path}, and think whether the key was seen`);
+}
+/** Reads a key file: the PEM block, an Ed25519 key, and the kind its first line names (when it names one). */
+function readKey(path, kind) {
+	checkKeyFile(path);
+	const text = readFileSync(path, "utf8");
+	const other = kind === "publisher" ? "store" : "publisher";
+	if (text.startsWith(`Ghostly ${other} key`)) throw new CliError("refused", `${path} is a ${other} key: ${kind === "publisher" ? "a store key never signs an app" : "a publisher key never signs a store index"} (WISP 1200 · Stores)`);
+	const block = PEM.exec(text);
+	let seed;
+	if (block) try {
+		const key = createPrivateKey(block[0]);
+		const d = key.asymmetricKeyType === "ed25519" ? key.export({ format: "jwk" }).d : void 0;
+		if (d) seed = fromBase64Url$1(d);
+	} catch {}
+	if (!seed || seed.length !== 32) throw new CliError("bad_request", `${path} holds no Ed25519 private key (a PEM "PRIVATE KEY" block, as openssl genpkey -algorithm ed25519 writes)`);
+	const signer = seedSigner(seed);
+	return {
+		signer,
+		key: toZ32(signer.publicKey),
+		created: false
+	};
+}
+/** Makes a key file: owner-only from the start, never over a file that is there. */
+function makeKey(path, kind) {
+	mkdirSync(dirname(path), {
+		recursive: true,
+		mode: 448
+	});
+	const { privateKey } = generateKeyPairSync("ed25519");
+	const pem = privateKey.export({
+		type: "pkcs8",
+		format: "pem"
+	});
+	const fd = openSync(path, "wx", 384);
+	try {
+		writeSync(fd, `${KEY_HEADER[kind]}\n${pem}`);
+	} finally {
+		closeSync(fd);
+	}
+	return {
+		...readKey(path, kind),
+		created: true
+	};
+}
+/** What the person is told on stderr when a key was made: where, which, and to back it up. Never the key. */
+function madeKeyNote(path, kind, key) {
+	return kind === "publisher" ? `new publisher key written to ${path}; back it up (${appFingerprint(key)}: an app is updated only with the key that signed it, and phase 1 has no recovery)` : `new store key written to ${path}; back it up and keep it offline (${appFingerprint(key)}: a store is its key)`;
+}
+var refused = (what, reading, extra = {}) => new CliError("refused", `${what} (${reading.reason}${reading.detail ? `: ${reading.detail}` : ""})`, {
+	reason: reading.reason,
+	...reading.detail ? { detail: reading.detail } : {},
+	...extra
+});
+/** A bundle file's bytes: its size is checked before it is read, so a huge file is refused unread. */
+function readBundleFile(path) {
+	const info = statSync(path);
+	if (info.isDirectory()) throw new CliError("bad_request", `${path} is a folder: name a .ghostlyapp file`);
+	if (info.size > APP_BUNDLE_LIMITS.bundleBytes) throw refused(`${path} is not a valid bundle`, {
+		reason: "too-large",
+		detail: `${info.size} bytes`
+	});
+	return new Uint8Array(readFileSync(path));
+}
+/**
+* A bundle at an https URL, as a client fetches one: `https:` only, no user or password, jsDelivr only at a full
+* commit (WISP 1200 · Manifest, "Every URL"); every redirect is held to the same rule, and the download stops past
+* 16 MiB.
+*/
+async function fetchBundle(url) {
+	let at = url;
+	for (let hop = 0;; hop++) {
+		if (!isAppUrl(at)) throw new CliError(hop ? "refused" : "usage", hop ? `${url} redirects to ${at}, which a client does not read (https only, no user or password, jsDelivr only at a full commit)` : `Not a URL a client reads: https only, at most ${APP_BUNDLE_LIMITS.url} characters, no user or password, and jsDelivr only as https://cdn.jsdelivr.net/gh/<owner>/<repo>@<40-hex commit>/<path>`);
+		let response;
+		try {
+			response = await fetch(at, {
+				redirect: "manual",
+				signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+			});
+		} catch (error) {
+			if (error instanceof Error && error.name === "TimeoutError") throw new CliError("timeout", `${at} did not answer in ${FETCH_TIMEOUT_MS / 1e3} s`);
+			throw new CliError("unavailable", `Could not read ${at}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		if (response.status >= 300 && response.status < 400 && response.headers.get("location")) {
+			await response.body?.cancel();
+			if (hop >= MAX_REDIRECTS) throw new CliError("refused", `${url} redirects more than ${MAX_REDIRECTS} times`);
+			at = new URL(response.headers.get("location"), at).href;
+			continue;
+		}
+		if (response.status === 404 || response.status === 410) {
+			await response.body?.cancel();
+			throw new CliError("not_found", `${at} answered ${response.status}`);
+		}
+		if (!response.ok || !response.body) {
+			await response.body?.cancel();
+			throw new CliError("unavailable", `${at} answered ${response.status}`);
+		}
+		const limit = APP_BUNDLE_LIMITS.bundleBytes;
+		const tooLarge = (bytes) => refused(`${url} is not a valid bundle`, {
+			reason: "too-large",
+			detail: `${bytes} bytes`
+		});
+		const length = Number(response.headers.get("content-length"));
+		if (Number.isFinite(length) && length > limit) {
+			await response.body.cancel();
+			throw tooLarge(length);
+		}
+		const chunks = [];
+		let total = 0;
+		const reader = response.body.getReader();
+		try {
+			for (;;) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				total += value.length;
+				if (total > limit) {
+					await reader.cancel();
+					throw tooLarge(`more than ${limit}`);
+				}
+				chunks.push(value);
+			}
+		} catch (error) {
+			if (error instanceof CliError) throw error;
+			if (error instanceof Error && error.name === "TimeoutError") throw new CliError("timeout", `${at} did not finish in ${FETCH_TIMEOUT_MS / 1e3} s`);
+			throw new CliError("unavailable", `Could not read ${at}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		const out = new Uint8Array(total);
+		let offset = 0;
+		for (const chunk of chunks) {
+			out.set(chunk, offset);
+			offset += chunk.length;
+		}
+		return out;
+	}
+}
+/** What a checked bundle is, as `app verify` and `app publish` print it. */
+function described(bundle, bytes) {
+	const m = bundle.manifest;
+	return {
+		ref: appRef(m.publisher, m.name),
+		publisher: m.publisher,
+		fingerprint: appFingerprint(m.publisher),
+		name: m.name,
+		title: m.title,
+		version: m.version,
+		sequence: m.sequence,
+		digest: bundle.digest,
+		bytes: bytes.length,
+		sha256: toBase64Url$1(createHash("sha256").update(bytes).digest())
+	};
+}
+/** `app verify <bundle|url>`: every check a client makes before it stores a bundle (WISP 1200 · Reading a bundle). */
+async function verifyApp(source) {
+	const bytes = /^[a-z][a-z0-9+.-]*:\/\//i.test(source) ? await fetchBundle(source) : readBundleFile(resolve(source));
+	const read = readAppBundle(bytes);
+	if (!read.ok) throw refused(`${source} is not a valid bundle`, read);
+	return {
+		valid: true,
+		...described(read.bundle, bytes),
+		manifest: read.bundle.manifest
+	};
+}
+/** Every file of the folder, as the bundle names it; dot files and folders are left out and listed. */
+function collectFiles(dir, leaveOut) {
+	const files = [];
+	const skipped = [];
+	let bytes = 0;
+	const walk = (folder) => {
+		for (const name of readdirSync(folder).sort()) {
+			const full = join(folder, name);
+			const path = relative(dir, full).split(sep).join("/");
+			if (leaveOut.has(full)) continue;
+			if (name.startsWith(".")) {
+				skipped.push(path);
+				continue;
+			}
+			const info = lstatSync(full);
+			if (info.isSymbolicLink()) throw new CliError("bad_request", `${path} is a link: a bundle holds the folder's own files (copy it in, or remove it)`);
+			if (info.isDirectory()) {
+				walk(full);
+				continue;
+			}
+			if (!info.isFile()) throw new CliError("bad_request", `${path} is not a file`);
+			files.push({
+				path,
+				full,
+				size: info.size
+			});
+			bytes += info.size;
+			if (files.length > APP_BUNDLE_LIMITS.files) throw refused(`${dir} holds more files than a bundle may`, {
+				reason: "too-many-files",
+				detail: `more than ${APP_BUNDLE_LIMITS.files}`
+			});
+			if (bytes > APP_BUNDLE_LIMITS.bundleBytes) throw refused(`${dir} holds more than a bundle may`, {
+				reason: "too-large",
+				detail: `more than ${APP_BUNDLE_LIMITS.bundleBytes} bytes of files`
+			});
+		}
+	};
+	walk(dir);
+	return {
+		files,
+		skipped
+	};
+}
+/** Fields of `ghostly-app.json` the command writes itself. */
+var WRITTEN = ["publisher", "files"];
+function readSource(path) {
+	if (!existsSync(path)) throw new CliError("not_found", `No ${APP_SOURCE} in ${dirname(path)}: it holds the manifest's fields (name, version, title, tagline, entry, permissions, runtime, license, ...) but publisher, sequence and files, which publish writes`);
+	let value;
+	try {
+		value = JSON.parse(readFileSync(path, "utf8"));
+	} catch (error) {
+		throw new CliError("bad_request", `${path} is not JSON: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new CliError("bad_request", `${path} is not a JSON object`);
+	const draft = value;
+	const written = WRITTEN.filter((k) => k in draft);
+	if (written.length) throw new CliError("bad_request", `${path} has ${written.join(" and ")}: publish writes ${written.length > 1 ? "them" : "it"} from the key and the folder's files`);
+	if (draft.ghostlyApp !== void 0 && draft.ghostlyApp !== 1) throw refused(`${path} is not a manifest this release makes`, {
+		reason: "unsupported-format",
+		detail: "ghostlyApp is not 1"
+	});
+	if (draft.sequence !== void 0 && !(Number.isSafeInteger(draft.sequence) && draft.sequence >= 1)) throw new CliError("bad_request", `${path}: sequence is a whole number from 1 (or leave it out: publish raises it by itself)`);
+	return draft;
+}
+/** Writes a file whole or not at all: a reader never sees half a bundle (and a dot file left by a crash is never bundled). */
+function writeWhole(path, bytes) {
+	const tmp = join(dirname(path), `.${basename(path)}.${process.pid}.tmp`);
+	writeFileSync(tmp, bytes);
+	renameSync(tmp, path);
+}
+/**
+* `app publish <dir> --key <file> [--out <file>]`: `<dir>/ghostly-app.json` (the manifest without `publisher`,
+* `sequence` and `files`) and every other file in `<dir>` become one signed bundle, by default `<dir>/app.ghostlyapp`.
+* The sequence is `--sequence` (higher than the bundle already at `--out`'s), else one more than that bundle's (or
+* the source's `sequence`, if higher, else 1). The
+* key file is made when it is missing and no earlier bundle is there to update.
+*/
+async function publishApp(dirArg, keyArg, outArg, sequenceArg) {
+	if (sequenceArg !== void 0 && !(Number.isSafeInteger(sequenceArg) && sequenceArg >= 1)) throw new CliError("usage", `--sequence takes a whole number from 1, not ${sequenceArg}`);
+	const dir = resolve(dirArg);
+	if (!statSync(dir).isDirectory()) throw new CliError("bad_request", `${dir} is not a folder`);
+	const keyPath = resolve(keyArg);
+	const out = resolve(outArg ?? join(dir, "app.ghostlyapp"));
+	const sourcePath = join(dir, APP_SOURCE);
+	const draft = readSource(sourcePath);
+	let previous = null;
+	if (existsSync(out)) {
+		const read = readAppBundle(readBundleFile(out));
+		if (!read.ok) throw refused(`${out} is there and is not a valid bundle: move it away, or name another --out`, read);
+		previous = read.bundle.manifest;
+	}
+	let key;
+	if (existsSync(keyPath)) key = readKey(keyPath, "publisher");
+	else if (previous) throw new CliError("not_found", `No key file ${keyPath}: ${out} is signed by ${appFingerprint(previous.publisher)}, and only that key publishes its next version`);
+	else key = makeKey(keyPath, "publisher");
+	if (previous && previous.publisher !== key.key) throw refused(`${out} is ${appRef(previous.publisher, previous.name)}, signed by another key (${appFingerprint(previous.publisher)}): a version of an app is signed by its own key`, { reason: "other-app" }, { publisher: previous.publisher });
+	if (previous && previous.name !== draft.name) throw refused(`${out} is the app ${JSON.stringify(previous.name)}, not ${JSON.stringify(draft.name)}: name another --out for another app`, { reason: "other-app" });
+	if (sequenceArg !== void 0 && previous && sequenceArg <= previous.sequence) throw refused(`--sequence ${sequenceArg} is not higher than the ${previous.sequence} of ${out}: every client refuses a lower one, and the same one with other content is equivocation`, { reason: sequenceArg < previous.sequence ? "rollback" : "equivocation" }, { previous: previous.sequence });
+	const sequence = sequenceArg ?? Math.max(previous ? previous.sequence + 1 : 1, draft.sequence ?? 1);
+	const { files, skipped } = collectFiles(dir, /* @__PURE__ */ new Set([
+		sourcePath,
+		out,
+		join(dir, APP_REVOKE_FILE)
+	]));
+	const contents = files.map((f) => ({
+		path: f.path,
+		bytes: new Uint8Array(readFileSync(f.full))
+	}));
+	const manifest = {
+		...draft,
+		ghostlyApp: 1,
+		publisher: key.key,
+		sequence,
+		files: contents.map((f) => ({
+			path: f.path,
+			size: f.bytes.length,
+			sha256: toBase64Url$1(createHash("sha256").update(f.bytes).digest())
+		}))
+	};
+	const checked = checkAppManifest(JSON.parse(JSON.stringify(manifest)));
+	if (!checked.ok) throw refused(`${sourcePath} and the folder's files make no valid manifest`, checked);
+	const { bytes: manifestBytes, signature } = await signAppObject(APP_PREFIXES.app, checked.manifest, key.signer);
+	const bundle = assembleAppBundle(manifestBytes, canonicalJsonBytes(signature), contents.map((f) => f.bytes));
+	const read = readAppBundle(bundle);
+	if (!read.ok) throw refused("The bundle made is not valid", read);
+	mkdirSync(dirname(out), { recursive: true });
+	writeWhole(out, bundle);
+	return {
+		...described(read.bundle, bundle),
+		previous: previous?.sequence ?? null,
+		out,
+		files: contents.map((f) => f.path),
+		...skipped.length ? { skipped } : {},
+		keyCreated: key.created,
+		...key.created ? { warning: madeKeyNote(keyPath, "publisher", key.key) } : {}
+	};
+}
+/**
+* `app revoke <dir> --key <file> (--digest <digest>... | --up-to <sequence>) [--reason <text>] [--bundle <file>]`: a
+* `ghostly-revoke/1` statement (WISP 1200 · Publisher keys, Revocation) for the app whose bundle is `<dir>/app.ghostlyapp`
+* (or `--bundle`), signed by that app's publisher key and added to `<dir>/ghostly-revoke.json`, which stays canonical.
+* The key is never made here: only the key that signed the app may revoke its versions.
+*/
+async function revokeApp(dirArg, keyArg, what) {
+	const dir = resolve(dirArg);
+	const bundlePath = resolve(what.bundle ?? join(dir, "app.ghostlyapp"));
+	const listPath = join(dir, APP_REVOKE_FILE);
+	const usage = "ghostly app revoke <dir> --key <file> (--digest <digest>... | --up-to <sequence>) [--reason <text>]";
+	const digests = what.digests ?? [];
+	if (digests.length > 0 === (what.upTo !== void 0)) throw new CliError("usage", `Give --digest (again for each) or --up-to, one of the two: ${usage}`);
+	if (what.upTo !== void 0 && !(Number.isSafeInteger(what.upTo) && what.upTo >= 1)) throw new CliError("usage", `--up-to takes a sequence, a whole number from 1, not ${what.upTo}`);
+	if (!existsSync(bundlePath)) throw new CliError("not_found", `No bundle ${bundlePath}: a revocation names the app of the bundle in <dir> (or --bundle)`);
+	const read = readAppBundle(readBundleFile(bundlePath));
+	if (!read.ok) throw refused(`${bundlePath} is not a valid bundle`, read);
+	const manifest = read.bundle.manifest;
+	const ref = appRef(manifest.publisher, manifest.name);
+	const keyPath = resolve(keyArg);
+	if (!existsSync(keyPath)) throw new CliError("not_found", `No key file ${keyPath}: only the key that signed ${ref} (${appFingerprint(manifest.publisher)}) revokes its versions`);
+	const key = readKey(keyPath, "publisher");
+	if (key.key !== manifest.publisher) throw refused(`${keyPath} is not the publisher key of ${ref} (${appFingerprint(manifest.publisher)}): a revocation by any other key is refused by every client`, { reason: "signature-key" });
+	const statement = digests.length ? {
+		ghostlyRevoke: 1,
+		app: ref,
+		digests
+	} : {
+		ghostlyRevoke: 1,
+		app: ref,
+		upTo: what.upTo
+	};
+	if (what.reason !== void 0) statement.reason = what.reason;
+	const problem = checkAppRevokeStatement(statement);
+	if (problem) throw refused("Not a revocation a client reads", {
+		reason: "bad-revocation",
+		detail: problem
+	});
+	let list = [];
+	if (existsSync(listPath)) {
+		const held = readAppRevocations(new Uint8Array(readFileSync(listPath)));
+		if (!held.ok) throw refused(`${listPath} is there and is not a valid ghostly-revoke.json: fix or move it first`, held);
+		list = held.revocations;
+	}
+	const signed = await signAppRevocation(statement, key.signer);
+	const same = list.some((r) => canonicalJson(r.statement) === canonicalJson(signed.statement));
+	if (!same) {
+		if (list.length >= APP_STATEMENT_LIMITS.revocations) throw refused(`${listPath} holds ${list.length} revocations already`, {
+			reason: "bad-revocation",
+			detail: `at most ${APP_STATEMENT_LIMITS.revocations}`
+		});
+		list = [...list, signed];
+		const bytes = canonicalJsonBytes(list);
+		const check = readAppRevocations(bytes);
+		if (!check.ok) throw refused("The revocation list made is not valid", check);
+		writeWhole(listPath, bytes);
+	}
+	return {
+		app: ref,
+		...digests.length ? {
+			digests,
+			current: digests.includes(read.bundle.digest)
+		} : {
+			upTo: what.upTo,
+			current: manifest.sequence <= what.upTo
+		},
+		...what.reason !== void 0 ? { reason: what.reason } : {},
+		added: !same,
+		revocations: list.length,
+		file: listPath
+	};
+}
+/**
+* `store sign <index> --key <file> [--out <dir>]`: a store index written by hand (any JSON layout; `key` may be left
+* out and is then the signing key's) becomes `ghostly-store.json`, canonical, and `ghostly-store.sig`, in `--out` or
+* beside the index. It is read back as a client reads it (`expires` at most 90 days ahead), and refused when the index
+* already there, signed by the same key, has a higher `sequence`, or the same one with other content.
+*/
+async function signStore(indexArg, keyArg, outArg, now = Math.floor(Date.now() / 1e3)) {
+	const indexPath = resolve(indexArg);
+	const keyPath = resolve(keyArg);
+	const outDir = resolve(outArg ?? dirname(indexPath));
+	let value;
+	try {
+		value = JSON.parse(readFileSync(indexPath, "utf8"));
+	} catch (error) {
+		if (error instanceof SyntaxError) throw new CliError("bad_request", `${indexPath} is not JSON: ${error.message}`);
+		throw error;
+	}
+	if (!value || typeof value !== "object" || Array.isArray(value)) throw new CliError("bad_request", `${indexPath} is not a JSON object`);
+	const index = value;
+	let key;
+	if (existsSync(keyPath)) key = readKey(keyPath, "store");
+	else if (index.key !== void 0) throw new CliError("not_found", `No key file ${keyPath}: the index names the store key ${typeof index.key === "string" ? appFingerprint(index.key) : JSON.stringify(index.key)}`);
+	else key = makeKey(keyPath, "store");
+	if (index.key !== void 0 && index.key !== key.key) throw refused(`${indexPath} names another store key than ${keyPath}'s (${appFingerprint(key.key)})`, { reason: "store-key" });
+	index.key = key.key;
+	const checked = checkAppStoreIndex(index);
+	if (!checked.ok) throw refused(`${indexPath} is not a valid store index`, checked);
+	const { indexBytes, sigBytes } = await signAppStore(index, key.signer);
+	const read = readAppStore(indexBytes, sigBytes, now, key.key);
+	if (!read.ok) throw refused(`${indexPath} would be refused by a client`, read);
+	const store = read.store;
+	const indexOut = join(outDir, STORE_INDEX_FILE), sigOut = join(outDir, STORE_SIG_FILE);
+	let previous = null;
+	if (existsSync(indexOut) && existsSync(sigOut)) {
+		const held = readAppStore(new Uint8Array(readFileSync(indexOut)), new Uint8Array(readFileSync(sigOut)), now);
+		if (held.ok && held.store.index.key === key.key) {
+			previous = held.store.index.sequence;
+			const decision = appStoreDecision({
+				key: key.key,
+				sequence: held.store.index.sequence,
+				digest: held.store.digest
+			}, {
+				key: key.key,
+				sequence: store.index.sequence,
+				digest: store.digest
+			});
+			if (decision === "rollback" || decision === "equivocation") throw refused(`${indexOut} already holds sequence ${held.store.index.sequence} of this store: ${decision === "rollback" ? "a lower one is refused by every client" : "the same one with other content is refused as equivocation"}; raise sequence`, { reason: decision }, { held: held.store.index.sequence });
+		}
+	}
+	mkdirSync(outDir, { recursive: true });
+	writeWhole(indexOut, indexBytes);
+	writeWhole(sigOut, sigBytes);
+	const notes = [...key.created ? [madeKeyNote(keyPath, "store", key.key)] : [], ...store.expired ? [`expires (${(/* @__PURE__ */ new Date(store.index.expires * 1e3)).toISOString()}) is past: clients still install from it and say the store was not updated since then`] : []];
+	return {
+		key: key.key,
+		fingerprint: appFingerprint(key.key),
+		name: store.index.name,
+		kind: store.index.kind,
+		sequence: store.index.sequence,
+		previous,
+		expires: store.index.expires,
+		expired: store.expired,
+		apps: store.index.apps.length,
+		removed: store.index.removed.length,
+		revoked: store.index.revoked.length,
+		digest: store.digest,
+		index: indexOut,
+		sig: sigOut,
+		keyCreated: key.created,
+		...notes.length ? { warning: notes.join("; ") } : {}
+	};
+}
+//#endregion
+//#region src/commands/apps.ts
+/** The key file a command signs with: always named, never a default, never on the command line itself. */
+function keyFile(value, usage) {
+	if (typeof value !== "string" || !value) throw new CliError("usage", `--key <file> is needed: ghostly ${usage}`);
+	return value;
+}
+var key = {
+	type: "string",
+	description: "The key file (made, owner-only, when it is missing)"
+};
+/**
+* The publisher tools of WISP 1200 (Apps · Publishing): they run here, on files, with no profile or daemon. One entry
+* per command, in alphabetical order (test/commands.test.ts checks).
+*/
+var commands$8 = {
+	"app publish": {
+		method: "app.publish",
+		usage: "app publish <dir> --key <file> [--out <file>]",
+		summary: "Bundle and sign an app (WISP 1200): <dir>/ghostly-app.json and every other file in <dir> become one .ghostlyapp, its sequence one more than the bundle at --out (default <dir>/app.ghostlyapp)",
+		args: ["dir"],
+		options: {
+			key: {
+				...key,
+				description: "The publisher key file (made, owner-only, on first use; back it up)"
+			},
+			out: {
+				type: "string",
+				description: "Where the bundle goes (default <dir>/app.ghostlyapp); the bundle there is the version this one follows"
+			},
+			sequence: {
+				type: "number",
+				description: "This version's sequence, higher than the bundle at --out's (default: one more than it)"
+			}
+		},
+		run: ({ options }, a) => publishApp(a.dir, keyFile(options.key, "app publish <dir> --key <file> [--out <file>] [--sequence n]"), options.out, options.sequence)
+	},
+	"app revoke": {
+		method: "app.revoke",
+		usage: "app revoke <dir> --key <file> (--digest <digest>... | --up-to <sequence>) [--reason <text>] [--bundle <file>]",
+		summary: "Revoke versions of your app (WISP 1200 · Revocation): a ghostly-revoke/1 statement signed with its publisher key, added to <dir>/ghostly-revoke.json",
+		args: ["dir"],
+		options: {
+			key: {
+				type: "string",
+				description: "The app's publisher key file (never made here)"
+			},
+			digest: {
+				type: "list",
+				description: "A version's digest, base64url as app verify prints it (again for each, up to 64)"
+			},
+			"up-to": {
+				type: "number",
+				description: "Every version with this sequence or a lower one"
+			},
+			reason: {
+				type: "string",
+				description: "Why, one line of up to 200 characters, shown to people"
+			},
+			bundle: {
+				type: "string",
+				description: "The bundle naming the app (default <dir>/app.ghostlyapp)"
+			}
+		},
+		run: ({ options }, a) => revokeApp(a.dir, keyFile(options.key, "app revoke <dir> --key <file> (--digest <digest>... | --up-to <sequence>) [--reason <text>]"), {
+			digests: options.digest,
+			upTo: options["up-to"],
+			reason: options.reason,
+			bundle: options.bundle
+		})
+	},
+	"app verify": {
+		method: "app.verify",
+		usage: "app verify <bundle|url>",
+		summary: "Check a .ghostlyapp as a client would, from a file or an https URL: its manifest and digest, or refused (exit 1) with the reason",
+		args: ["bundle"],
+		run: (_, a) => verifyApp(a.bundle)
+	},
+	"store sign": {
+		method: "store.sign",
+		usage: "store sign <index> --key <file> [--out <dir>]",
+		summary: "Sign a store index (WISP 1200 · Stores): writes ghostly-store.json, canonical, and ghostly-store.sig beside it or in --out",
+		args: ["index"],
+		options: {
+			key: {
+				...key,
+				description: "The store key file (made, owner-only, when it is missing and the index names no key; keep it offline)"
+			},
+			out: {
+				type: "string",
+				description: "The folder to write ghostly-store.json and ghostly-store.sig in (default: the index's)"
+			}
+		},
+		run: ({ options }, a) => signStore(a.index, keyFile(options.key, "store sign <index> --key <file> [--out <dir>]"), options.out)
+	}
+};
+//#endregion
 //#region src/commands/shared.ts
 var wait = {
 	wait: {
@@ -14055,7 +14639,8 @@ var COMMANDS = {
 	...commands$1,
 	...commands$2,
 	...commands,
-	...commands$7
+	...commands$7,
+	...commands$8
 };
 /** Commands that take text (argument or stdin), with the secret guard and delivery waits. */
 var TEXT_COMMANDS = {
@@ -14668,10 +15253,11 @@ function loadCallStack() {
 }
 /**
 * The ICE servers of a call, as libdatachannel takes them: the apps' STUN servers (RTC_CONFIG; libjuice uses the
-* first), then the profile's own (Settings `iceServers`: a TURN relay, typically), as the apps' calls use them.
+* first; none with `GHOSTLY_STUN=0`), then the profile's own (Settings `iceServers`: a TURN relay, typically), as the
+* apps' calls use them.
 */
-function callIceServers(extra = []) {
-	const out = (RTC_CONFIG.iceServers ?? []).flatMap((server) => [server.urls].flat()).slice(0, 2);
+function callIceServers(extra = [], env = process.env) {
+	const out = env.GHOSTLY_STUN === "0" ? [] : (RTC_CONFIG.iceServers ?? []).flatMap((server) => [server.urls].flat()).slice(0, 2);
 	for (const server of callRtcConfig(extra).iceServers?.slice(RTC_CONFIG.iceServers?.length ?? 0) ?? []) for (const url of [server.urls].flat()) {
 		const m = /^(stun|turns?):([^:?\s]+)(?::(\d+))?(?:\?transport=(udp|tcp))?$/i.exec(url);
 		if (!m) continue;
@@ -16050,6 +16636,203 @@ function groupShape(group) {
 	};
 }
 //#endregion
+//#region ../browser/src/platform/irohWeb.ts
+/**
+* Iroh (WISP 102) in a browser: the same QUIC/TLS session and binding as the
+* Desktop's native Iroh, but relay only. A page cannot send UDP, so every
+* packet goes through an Iroh relay over a WebSocket; the relay sees who talks
+* to whom and when, never the frames.
+*
+* The wasm (about 1 MB gzip) loads on the first chat that starts an endpoint,
+* never on the app's first load.
+*/
+/**
+* n0's public relays, the same ones the Desktop's Iroh homes on by default. Iroh itself names them with the trailing
+* dot of a full domain name (`use1-1.relay.n0.iroh.link.`), and compares relay URLs as text; here they have none,
+* because WebKit opens no host name that ends in a dot. `BROWSER_SPELLING` is what keeps the two one relay.
+*/
+var DEFAULT_IROH_RELAYS = [
+	"https://use1-1.relay.n0.iroh.link/",
+	"https://euc1-1.relay.n0.iroh.link/",
+	"https://aps1-1.relay.n0.iroh.link/",
+	"https://usw1-1.relay.n0.iroh.link/"
+];
+/**
+* The spelling of every relay URL handed to the wasm Iroh (`irohRelayUrl`): the relays it homes on and a contact's
+* relay before a dial. One spelling, so a contact on this endpoint's relay is reached over the connection already
+* open to it; without the dot, so Safari can open it (a Desktop's record names its relay with the dot).
+*/
+var BROWSER_SPELLING = "plain";
+/**
+* Why a relay URL cannot be used, or null. TLS, except on this machine (a local `iroh-relay --dev`): a page
+* may not open plain WebSockets elsewhere, and the relay's operator would see traffic metadata in the clear.
+*/
+function irohRelayProblem(value) {
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		return `Not a relay address: ${value}`;
+	}
+	const local = [
+		"localhost",
+		"127.0.0.1",
+		"[::1]"
+	].includes(url.hostname);
+	if (url.protocol !== "https:" && !(url.protocol === "http:" && local)) return `Use an https:// relay address: ${value}`;
+	if (url.username || url.password || url.search || url.hash || value.length > 256) return `Not a relay address: ${value}`;
+	return null;
+}
+var loaded = null;
+/** Loads the wasm once per page. Tests pass their own `load` (Node reads the file). */
+function loadIrohWasm() {
+	loaded ??= import("./assets/ghostly_iroh_web-Dvzh3Y6E.js").then(async (module) => {
+		await module.default();
+		return module;
+	}).catch((error) => {
+		loaded = null;
+		throw error;
+	});
+	return loaded;
+}
+var SEND_BUDGET = 122880;
+var MAX_FRAME = 61440;
+/** One paired channel over one QUIC stream. Sends are queued in order. */
+var IrohWebChannel = class {
+	conn;
+	forget;
+	reader = null;
+	buffered = [];
+	queue = Promise.resolve();
+	closed = false;
+	bufferedAmount = 0;
+	sendBudget = SEND_BUDGET;
+	onClose = null;
+	constructor(conn, forget) {
+		this.conn = conn;
+		this.forget = forget;
+		this.read();
+	}
+	get onMessage() {
+		return this.reader;
+	}
+	set onMessage(reader) {
+		this.reader = reader;
+		if (reader) for (const text of this.buffered.splice(0)) reader(text);
+	}
+	async read() {
+		try {
+			for (;;) {
+				const text = await this.conn.recv();
+				if (text === void 0 || this.closed) break;
+				if (this.reader) this.reader(text);
+				else if (this.buffered.length < 64) this.buffered.push(text);
+				else break;
+			}
+		} catch {}
+		this.close();
+	}
+	send(data) {
+		if (typeof data !== "string" || this.closed || !data.length || data.length > MAX_FRAME || this.bufferedAmount + data.length > SEND_BUDGET) throw new Error("Iroh channel is closed or its send budget is full");
+		this.bufferedAmount += data.length;
+		this.queue = this.queue.then(() => this.closed ? void 0 : this.conn.send(data)).catch(() => this.close()).finally(() => {
+			this.bufferedAmount -= data.length;
+		});
+	}
+	drained() {
+		return this.queue;
+	}
+	get rttMs() {
+		const rtt = this.conn.rtt();
+		return rtt >= 0 ? rtt : void 0;
+	}
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		this.buffered = [];
+		try {
+			this.conn.close();
+		} catch {}
+		this.forget();
+		this.onClose?.();
+	}
+};
+/** A NativeEndpoint for `iroh/1`, as the Desktop's is, for one chat's transport seed. */
+async function createIrohWebEndpoint(seedB64, options = {}) {
+	const seed = fromBase64Url$1(seedB64);
+	if (seed.length !== 32) throw new Error("Invalid transport seed");
+	const relays = [...new Set((options.relays?.length ? options.relays : DEFAULT_IROH_RELAYS).map((relay) => irohRelayUrl(relay, BROWSER_SPELLING)))];
+	const node = await (await (options.load ?? loadIrohWasm)()).IrohNode.start(seed, relays, options.onlineMs ?? 1e4);
+	const channels = /* @__PURE__ */ new Set();
+	let stopped = false;
+	let handler = null;
+	const early = [];
+	const bind = (conn) => {
+		const channel = new IrohWebChannel(conn, () => channels.delete(channel));
+		channels.add(channel);
+		return {
+			channel,
+			binding: conn.binding()
+		};
+	};
+	const endpoint = {
+		transport: "iroh/1",
+		descriptor: {
+			...node.address(),
+			relayed: true
+		},
+		onDescriptor: null,
+		get onConnection() {
+			return handler;
+		},
+		set onConnection(value) {
+			handler = value;
+			if (value) for (const bound of early.splice(0)) value(bound);
+		},
+		async connect(descriptor) {
+			if (stopped) throw new Error("Iroh endpoint is stopped");
+			const conn = await node.connect(irohDescriptor(descriptor, BROWSER_SPELLING), options.connectMs ?? 2e4);
+			if (stopped) {
+				conn.close();
+				throw new Error("Iroh endpoint is stopped");
+			}
+			return bind(conn);
+		},
+		async close() {
+			if (stopped) return;
+			stopped = true;
+			for (const channel of [...channels]) channel.close();
+			for (const bound of early.splice(0)) bound.channel.close();
+			await node.close().catch(() => {});
+		}
+	};
+	(async () => {
+		while (!stopped) {
+			let conn;
+			try {
+				conn = await node.accept();
+			} catch {
+				break;
+			}
+			if (!conn) break;
+			if (stopped) {
+				conn.close();
+				break;
+			}
+			const bound = bind(conn);
+			const accept = endpoint.onConnection;
+			if (accept) accept(bound);
+			else if (early.length < 4) early.push(bound);
+			else bound.channel.close();
+		}
+		if (!stopped) {
+			endpoint.onUnavailable?.();
+			await endpoint.close();
+		}
+	})();
+	return endpoint;
+}
+//#endregion
 //#region ../browser/src/engine/paymentAdapters/fedimintSdk.ts
 var fedimintDatabase = (id) => `ghostly-fedimint-${id}.db`;
 var MODULE_WASM = () => import("./assets/fedimint_client_wasm_bg-BtHHlFpp.js");
@@ -16936,6 +17719,39 @@ function pkarrRelays(env = process.env) {
 	return relays;
 }
 /**
+* The Iroh relays of a private network or a test, `GHOSTLY_IROH_RELAYS` ("https://…,…"; http:// on loopback): the only
+* relays this process's Iroh homes on, whatever the profile's `irohRelays` setting says. Null when unset (the setting,
+* else n0's public relays).
+*/
+function irohRelays(env = process.env) {
+	const relays = (env.GHOSTLY_IROH_RELAYS ?? "").split(",").map((url) => url.trim()).filter(Boolean);
+	if (!relays.length) return null;
+	const bad = relays.map((url) => irohRelayProblem(url)).find(Boolean);
+	if (bad) throw new CliError("usage", `GHOSTLY_IROH_RELAYS: ${bad}`);
+	return relays;
+}
+/**
+* The apps' public STUN servers (Google's, `RTC_CONFIG`), which every WebRTC connection asks for its public address:
+* `GHOSTLY_STUN=0` leaves them out (a private network, or tests on one machine, where host candidates connect). The
+* profile's own `iceServers` stay.
+*/
+function publicStun(env = process.env) {
+	return env.GHOSTLY_STUN !== "0";
+}
+/** An RTC configuration without the apps' public STUN servers. */
+function withoutPublicStun(config) {
+	if (!config?.iceServers) return config;
+	const ours = new Set((RTC_CONFIG.iceServers ?? []).flatMap((server) => [server.urls].flat()));
+	const iceServers = config.iceServers.map((server) => ({
+		...server,
+		urls: [server.urls].flat().filter((url) => !ours.has(url))
+	})).filter((server) => server.urls.length);
+	return {
+		...config,
+		iceServers
+	};
+}
+/**
 * The Mainline DHT, for Pkarr beside the relays (`RelaysAndDht`): `GHOSTLY_DHT=0` leaves it out (relays only, as the web
 * app), `GHOSTLY_DHT_BOOTSTRAP` ("host:port,…") replaces the public routers (a testnet; one all on loopback binds there).
 * `GHOSTLY_PKARR_RELAYS` without a bootstrap leaves it out too, as on the Desktop: a private network stays off the
@@ -16971,12 +17787,43 @@ async function installWebRtc() {
 			"RTCPeerConnectionIceEvent",
 			"RTCCertificate"
 		]) scope[name] ??= polyfill[name];
+		refuseDataAnswers(scope);
+		if (!publicStun()) leaveOutPublicStun(scope);
 		return true;
 	} catch (error) {
 		process.stderr.write(`ghostly: WebRTC is unavailable (${error instanceof Error ? error.message : String(error)}); chats use HyperDHT, Iroh or the DHT\n`);
 		return false;
 	}
 }
+/**
+* For tests: `GHOSTLY_TEST_REFUSE_DATA_ANSWERS=<n>` refuses one in every n answers this process applies to its offers
+* (the first, the n+1st, and so on), as libdatachannel 0.24.5 refuses one in its race (`ANSWER_REFUSED_REDIALS` in
+* packages/core/src/datalink.ts): the connection closes, and setRemoteDescription throws.
+*/
+function refuseDataAnswers(scope) {
+	const every = Number(process.env.GHOSTLY_TEST_REFUSE_DATA_ANSWERS) || 0;
+	if (every <= 0) return;
+	let answers = 0;
+	const Base = scope.RTCPeerConnection;
+	scope.RTCPeerConnection = class extends Base {
+		async setRemoteDescription(description) {
+			if (description.type === "answer" && answers++ % every === 0) {
+				this.close();
+				throw new Error("libdatachannel error while adding remote description: Got a remote candidate without ICE transport (GHOSTLY_TEST_REFUSE_DATA_ANSWERS)");
+			}
+			return super.setRemoteDescription(description);
+		}
+	};
+}
+/** `GHOSTLY_STUN=0`: every connection the engine makes leaves the apps' public STUN servers out of its configuration. */
+function leaveOutPublicStun(scope) {
+	const Base = scope.RTCPeerConnection;
+	scope.RTCPeerConnection = class extends Base {
+		constructor(config) {
+			super(withoutPublicStun(config));
+		}
+	};
+}
 /** Server-sent events, which browsers have and Node does not: Arkade follows its server with them. */
 async function installEventSource() {
 	const scope = globalThis;
@@ -17017,13 +17864,17 @@ function leftOutIn(mark) {
 }
 async function startRuntime(paths, options = {}) {
 	const pinned = pkarrRelays();
+	const pinnedIroh = irohRelays();
 	const trace = process.env.GHOSTLY_LINK_TRACE;
-	if (trace) setLinkTraceSink((line) => appendFileSync(trace, line + "\n", { mode: 384 }));
+	if (trace) {
+		setLinkTraceSink((line) => appendFileSync(trace, line + "\n", { mode: 384 }));
+		(await import("./assets/joinTrace-CO8mlhNO.js").then((n) => n.t)).setJoinTraceSink((line) => appendFileSync(trace, line + "\n", { mode: 384 }));
+	}
 	const store = await openPersistentIndexedDb(paths.db);
 	const restored = join(paths.dir, RESTORED_MARK);
 	if (existsSync(restored)) {
 		try {
-			const rows = await import("./assets/restoredRows-C1O9FfA4.js");
+			const rows = await import("./assets/restoredRows-lhTKGmCO.js");
 			await rows.markRestoredWallet();
 			await rows.markLeftOutFiles(leftOutIn(restored));
 			await store.compact();
@@ -17042,19 +17893,20 @@ async function startRuntime(paths, options = {}) {
 	await installEventSource();
 	await preloadWalletModules();
 	(await import("./assets/ghostly_iroh_web-Dvzh3Y6E.js")).initSync({ module: irohWasmBytes() });
-	const [{ registerFileBytes }, { NodeFileBytes }] = await Promise.all([import("./assets/fileBytes-DxiJHmTk.js").then((n) => n.o), import("./assets/fileBytes-BQ84L9Fe.js")]);
+	const [{ registerFileBytes }, { NodeFileBytes }] = await Promise.all([import("./assets/fileBytes-3AQ2tJzW.js").then((n) => n.o), import("./assets/fileBytes-CAZDydIe.js")]);
 	registerFileBytes("native", async () => new NodeFileBytes(paths.files), true);
-	const [{ EngineServer }, { createHyperEndpoint }] = await Promise.all([import("./assets/server-CXFTDnFI.js").then((n) => n.t), import("./assets/endpoint-CaSbSFDw.js")]);
+	const [{ EngineServer }, { createHyperEndpoint }] = await Promise.all([import("./assets/server-TamKsfmC.js").then((n) => n.t), import("./assets/endpoint-CaSbSFDw.js")]);
 	const network = hyperdhtNetwork();
 	const dht = mainlineNetwork();
-	const mainline = dht.off ? null : new (await (import("./assets/mainline-dkA94eh2.js"))).Mainline({
+	const mainline = dht.off ? null : new (await (import("./assets/mainline-BabMhm8L.js"))).Mainline({
 		bootstrap: dht.bootstrap,
 		host: dht.host
 	});
-	const transport = mainline || pinned ? new (await (import("./assets/mainline-dkA94eh2.js"))).RelaysAndDht(mainline, pinned ? { relays: pinned } : {}, !!pinned) : null;
+	const transport = mainline || pinned ? new (await (import("./assets/mainline-BabMhm8L.js"))).RelaysAndDht(mainline, pinned ? { relays: pinned } : {}, !!pinned) : null;
 	const server = new EngineServer({
 		...transport ? { transport } : {},
 		irohWeb: true,
+		...pinnedIroh ? { irohRelays: pinnedIroh } : {},
 		singleDevice: true,
 		nativeTransports: { "hyperdht/1": (seedB64) => createHyperEndpoint(fromBase64Url$1(seedB64), network) },
 		automaticWallets: false,
@@ -18448,6 +19300,15 @@ async function tableCommand(name, argv) {
 	const g = globals(parsed);
 	pretty = g.pretty;
 	const args = positionals(command, parsed.positionals);
+	if (command.run) {
+		const result = await command.run(parsed, args);
+		if (typeof result.warning === "string") {
+			process.stderr.write(`ghostly: ${result.warning}\n`);
+			delete result.warning;
+		}
+		print(result);
+		return;
+	}
 	const params = command.params?.(parsed, args) ?? {};
 	for (const key of Object.keys(params)) if (params[key] === void 0) delete params[key];
 	if (command.method === "identity.complete") {
@@ -18623,6 +19484,6 @@ async function run(argv) {
 //#region src/bin.ts
 run(process.argv.slice(2));
 //#endregion
-export { onAdaptersChanged as $, intentRepository as A, MESSAGE_DETAILS_MAX_BYTES as B, ProviderSources as C, FileAppender as Ct, requireTurn as D, streamStored as Dt, refuseAway as E, storedSize as Et, ModeGate as F, fakesLightning as G, BITCOIN_INVOICE_ON_TESTNET as H, WrongNetworkError as I, mintNetwork as J, isTestMint as K, networkLabel as L, sealSeed as M, unsealSeed as N, setAwayWallets as O, ModeChanged as P, identityProviders as Q, CASHU_MINT_SOURCE as R, lightningPaying as S, paymentWireId as St, awayFrom as T, removeStored as Tt, DEFAULT_MINTS as U, WALLET_TYPES as V, TEST_MINT as W, BACKUP_MEDIA_TYPE as X, paysItsOwnInvoices as Y, MAX_BACKUP_BYTES as Z, normalizePhrase as _, pairedWireReply as _t, createFailure as a, SourceConfigError as at, breezDatabasesFor as b, replyTo as bt, paymentNetwork as c, networkMode as ct, networkReason as d, resolveAtprotoDid as dt, registeredLightningProviders as et, rpcHost as f, setOwnDidSource as ft, isRecoveryPhrase as g, groupReply as gt, cardsKey as h, chosenResolver as ht, assertConfirmedReal as i, PROVIDER_PLATFORMS as it, newDeviceKey as j, setSingleWriterGate as k, paymentNetworksOf as l, redact as lt, LightningCards as m, verifyIdentity as mt, loadFedimintSdk as n, reserveAdapterIds as nt, createTiming as o, SourceUnreachableError as ot, CASHU_CARD as p, boundedIdentityFetch as pt, isWorthlessMint as q, WALLET_NAMES as r, NothingSpentError as rt, crossNetwork as s, isNothingSpentError as st, fedimintDatabase as t, registeredOnchainProviders as tt, walletInstances as u, assertPublicServer as ut, breezDatabase as v, receivedPairedReply as vt, sourceKey as w, readStored as wt, dropBreezDatabase as x, paymentAlias as xt, breezDatabaseInUse as y, replyRef as yt, cashuMint as z };
+export { BACKUP_MEDIA_TYPE as $, requireTurn as A, 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 };
 
 //# sourceMappingURL=ghostly.mjs.map