@ghostlytools/cli 1.3.9 → 1.4.0

package/dist/assets/{host-DPy0eaH9.js → host-Drd-c4VO.js}

@@ -1,9 +1,9 @@
-import { $o as extractParamsFromSdp, Ai as isPublicAddress, Jo as RTC_CONFIG, Qo as callSignalHeardAt, Xo as buildSdpFromSignal, Yo as answersOffer, Zo as callRtcConfig, es as parseCallSignal, oi as checkPushEndpoint, qo as CALL_SIGNAL_MAX_AGE_MS, tl as setLinkTraceSink, ts as signalHasVideo, xl as fromBase64Url } from "./src-Dg1bvMNv.js";
-import { a as fedimintSdkOn, r as irohRelayProblem } from "./irohWeb-z5QDDWa-.js";
-import { r as asCliError, t as CliError } from "./errors-B-zMxbcd.js";
-import { a as findChat } from "./apiKit-B4qhnLQT.js";
-import { _ as flushCardUpdates, c as paymentJson, d as nodeLocalFetch, f as chatJson, g as resumeHolds, h as groupMessageJson, l as reportAppFrames, m as groupJson, p as chatMessageJson, r as callApi, u as servedApps } from "./api-BCrwJ57L.js";
-import { n as RESTORED_MARK, r as acquireLock } from "./profiles-gPCjLOQq.js";
+import { Ao as signalHasVideo, Co as RTC_CONFIG, Do as callSignalHeardAt, Eo as callRtcConfig, Oo as extractParamsFromSdp, So as CALL_SIGNAL_MAX_AGE_MS, To as buildSdpFromSignal, Xr as checkPushEndpoint, Zl as fromBase64Url, bi as isPublicAddress, jl as setLinkTraceSink, ko as parseCallSignal, wo as answersOffer } from "./src-DzXL-GYu.js";
+import { a as fedimintSdkOn, r as irohRelayProblem } from "./irohWeb-DHCxSvHF.js";
+import { r as asCliError, t as CliError } from "./errors-BLSPp0tK.js";
+import { a as findChat } from "./apiKit-BpIUCwa-.js";
+import { _ as flushCardUpdates, c as paymentJson, d as nodeLocalFetch, f as chatJson, g as resumeHolds, h as groupMessageJson, l as reportAppFrames, m as groupJson, p as chatMessageJson, r as callApi, u as servedApps } from "./api-JMkEO0RR.js";
+import { n as RESTORED_MARK, r as acquireLock } from "./profiles-DSxPYdlU.js";
 import { i as proof, l as privateFolder, n as newDaemonSecret, s as ownFolder } from "./daemonProof-B53VnZ1Z.js";
 import { createRequire } from "node:module";
 import { appendFileSync, chmodSync, closeSync, existsSync, fstatSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
@@ -313,7 +313,7 @@ var RtpWriter = class {
 		return Buffer.concat([header, payload]);
 	}
 };
-/** The most silence a gap in the packets becomes. */
+/** The most frames a gap in the packets becomes (concealed by the decoder, see CallAudio). */
 var MAX_LOST_FRAMES = 3;
 /** Sequence numbers compared across the 16-bit wrap: positive when `a` comes after `b`. */
 function sequenceDelta(a, b) {
@@ -322,7 +322,7 @@ function sequenceDelta(a, b) {
 }
 /**
 * Puts packets back in order, holding at most `depth` of them for one that is late: a lost packet costs one frame
-* of silence (40 ms of waiting at most), a duplicate or a packet that came too late is dropped, and a new stream (its
+* the decoder conceals (40 ms of waiting at most), a duplicate or a packet that came too late is dropped, and a new stream (its
 * SSRC changed, or its sequence jumped) starts over.
 */
 var ReorderBuffer = class {
@@ -380,6 +380,8 @@ var CallAudio = class {
 	samples;
 	silence;
 	pending = Buffer.alloc(0);
+	/** What the decoder concealed for the current gap and is not handed on yet (see `conceal`). */
+	concealed = null;
 	timer = null;
 	startedAt = 0;
 	ticks = 0;
@@ -474,15 +476,34 @@ var CallAudio = class {
 		if (!rtp || rtp.payloadType !== this.options.payloadType) return;
 		for (const item of this.reorder.push(rtp)) {
 			let pcm;
-			if ("lost" in item) pcm = this.silence;
-			else try {
-				pcm = this.options.decoder.decode(item.payload);
-			} catch {
-				pcm = this.silence;
+			if ("lost" in item) pcm = this.conceal();
+			else {
+				this.concealed = null;
+				try {
+					pcm = this.options.decoder.decode(item.payload);
+				} catch {
+					pcm = this.silence;
+				}
 			}
 			this.emit(pcm);
 		}
 	}
+	/**
+	* A frame for one that never came: the decoder's loss concealment (libopus PLC, what an empty packet decodes to), as
+	* the apps' WebRTC stacks do, not a frame of silence (a click). opusscript conceals 60 ms at a time (its largest
+	* frame), so one run of it serves the frames of a gap in turn (ReorderBuffer gives MAX_LOST_FRAMES at most).
+	*/
+	conceal() {
+		if (!this.concealed || this.concealed.length < this.frame) try {
+			this.concealed = Buffer.from(this.options.decoder.decode(Buffer.alloc(0)));
+		} catch {
+			this.concealed = null;
+		}
+		if (!this.concealed || this.concealed.length < this.frame) return this.silence;
+		const pcm = this.concealed.subarray(0, this.frame);
+		this.concealed = this.concealed.subarray(this.frame);
+		return pcm;
+	}
 	/** Hands decoded audio on in 20 ms frames, whatever the contact's packet length (10, 20, 40 or 60 ms). */
 	emit(pcm) {
 		let data = this.pending.length ? Buffer.concat([this.pending, pcm]) : pcm;
@@ -3397,6 +3418,7 @@ async function openPersistentIndexedDb(dir, options = {}) {
 	const classes = await probeClasses(factory);
 	dropIndexEntriesByRecord(classes, (a, b) => factory.cmp(a, b));
 	readWithoutCopy(classes);
+	startInOnePass(classes);
 	const order = keyOrder((a, b) => factory.cmp(a, b));
 	const rowsPath = join(dir, ROWS);
 	const rowsFound = existsSync(rowsPath);
@@ -3568,11 +3590,7 @@ async function openPersistentIndexedDb(dir, options = {}) {
 			trees?.abort(this._rollbackLog);
 		}
 		const dispatched = dispatch.call(this, event);
-		if ((event.type === "complete" || event.type === "abort") && this._state === "finished") {
-			const list = this.db._rawDatabase.transactions;
-			const at = list.indexOf(this);
-			if (at >= 0) list.splice(at, 1);
-		}
+		if ((event.type === "complete" || event.type === "abort") && this._state === "finished") dropEnded(this.db._rawDatabase, this);
 		return dispatched;
 	};
 	const deleteDatabase = factory.deleteDatabase.bind(factory);
@@ -3918,6 +3936,7 @@ async function probeClasses(factory) {
 		ObjectStore: rawStore.constructor,
 		Index: rawStore.rawIndexes.get("i").constructor,
 		RecordStore: rawStore.records.constructor,
+		Connection: db.constructor,
 		constraintError: Error
 	};
 	const probe = new classes.RecordStore(true);
@@ -4029,6 +4048,107 @@ function readWithoutCopy(classes) {
 		return values;
 	};
 }
+/** Transactions whose last event is out, by database, and dropped from its list at the next turn: all at once. */
+var ended = /* @__PURE__ */ new WeakMap();
+/** A finished transaction's place in its database's list, given back: one walk of the list for all that ended in a turn. */
+function dropEnded(db, transaction) {
+	let gone = ended.get(db);
+	if (gone) {
+		gone.add(transaction);
+		return;
+	}
+	ended.set(db, gone = /* @__PURE__ */ new Set([transaction]));
+	setImmediate(() => {
+		ended.delete(db);
+		const list = db.transactions;
+		let kept = 0;
+		for (const held of list) if (!gone.has(held)) list[kept++] = held;
+		list.length = kept;
+	});
+}
+/** The classes whose scheduler starts every transaction it can in one pass: shared by every store opened. */
+var onePass = /* @__PURE__ */ new WeakSet();
+/**
+* fake-indexeddb's scheduler runs at every transaction's start and end, checks each waiting transaction against every
+* running one and every one waiting before it, and starts one per pass; and each transaction made looks through every
+* other one for an upgrade running. A burst of reads (a look at each queued text) cost the square of their number, the
+* cube with a write waiting among them, and held the event loop all along (2,000 reads around a write: 19 s).
+*
+* A pass here walks the transactions once, in order, and starts each one that may run: a write once no running
+* transaction shares a store with it, a read once no running write does, neither behind a waiting one that shares a
+* store with it (the order IndexedDB keeps). The passes asked for before one runs are that one, and a transaction's end
+* asks for none while nothing waits. A transaction made while no upgrade of its database runs skips the look for one.
+* Databases made before this (the probe's) keep fake-indexeddb's scheduler: each binds the one it is made with.
+*/
+function startInOnePass(classes) {
+	const proto = classes.Database.prototype;
+	if (onePass.has(proto)) return;
+	onePass.add(proto);
+	const scheduling = /* @__PURE__ */ new WeakMap();
+	proto.processTransactions = function(event) {
+		let state = scheduling.get(this);
+		if (!state) scheduling.set(this, state = {
+			asked: false,
+			blocked: 0
+		});
+		if (state.asked || event !== void 0 && !state.blocked) return;
+		state.asked = true;
+		setImmediate(() => {
+			state.asked = false;
+			startRunnable(this, state);
+		});
+	};
+	const connection = classes.Connection.prototype;
+	const { transaction } = connection;
+	const upgrades = /* @__PURE__ */ new WeakMap();
+	connection.transaction = function(names, mode, options) {
+		const raw = this._rawDatabase;
+		if (mode === "versionchange") {
+			const made = transaction.call(this, names, mode, options);
+			upgrades.set(raw, (upgrades.get(raw) ?? 0) + 1);
+			const done = () => {
+				upgrades.set(raw, upgrades.get(raw) - 1);
+			};
+			made.addEventListener("complete", done);
+			made.addEventListener("abort", done);
+			return made;
+		}
+		if (upgrades.get(raw)) return transaction.call(this, names, mode, options);
+		const list = raw.transactions;
+		raw.transactions = [];
+		try {
+			return transaction.call(this, names, mode, options);
+		} finally {
+			list.push(...raw.transactions);
+			raw.transactions = list;
+		}
+	};
+}
+function startRunnable(db, state) {
+	state.blocked = 0;
+	const writing = /* @__PURE__ */ new Set(), reading = /* @__PURE__ */ new Set(), blocked = /* @__PURE__ */ new Set();
+	const holds = (scope, stores) => {
+		for (const store of scope) if (stores.has(store)) return true;
+		return false;
+	};
+	const take = (transaction) => {
+		for (const store of transaction._scope) (transaction.mode === "readonly" ? reading : writing).add(store);
+	};
+	const list = db.transactions.filter((transaction) => transaction._state !== "finished");
+	for (const transaction of list) if (transaction._started) take(transaction);
+	for (const transaction of list) {
+		if (transaction._started || transaction._state === "finished") continue;
+		if (!(!holds(transaction._scope, blocked) && !holds(transaction._scope, writing) && (transaction.mode === "readonly" || !holds(transaction._scope, reading)))) {
+			for (const store of transaction._scope) blocked.add(store);
+			state.blocked++;
+			continue;
+		}
+		take(transaction);
+		transaction.addEventListener("complete", db.processTransactions);
+		transaction.addEventListener("abort", db.processTransactions);
+		transaction._start();
+	}
+}
 /** 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 = [];
@@ -4580,7 +4700,7 @@ async function startRuntime(paths, options = {}) {
 	const restored = join(paths.dir, RESTORED_MARK);
 	if (existsSync(restored)) {
 		try {
-			const rows = await import("./restoredRows-Db3oUTko.js");
+			const rows = await import("./restoredRows-DeBImGRd.js");
 			await rows.markRestoredWallet();
 			await rows.markLeftOutFiles(leftOutIn(restored));
 			await store.compact();
@@ -4599,16 +4719,17 @@ async function startRuntime(paths, options = {}) {
 	await installEventSource();
 	await preloadWalletModules();
 	(await import("./ghostly_iroh_web-BsAEFIjl.js")).initSync({ module: irohWasmBytes() });
-	const [{ registerFileBytes }, { NodeFileBytes }] = await Promise.all([import("./fileBytes-CgbibpbV.js"), import("./fileBytes-CfSXjTFa.js")]);
+	const [{ registerFileBytes }, { NodeFileBytes }] = await Promise.all([import("./fileBytes-C2jycN_7.js"), import("./fileBytes-D6fqFQEX.js")]);
 	registerFileBytes("native", async () => new NodeFileBytes(paths.files), true);
-	const [{ EngineServer }, { createHyperEndpoint }] = await Promise.all([import("./server-p5DJnN7T.js"), import("./endpoint-BOTFMpfS.js")]);
+	if (await (await import("./blobFiles-B0rNnHlO.js")).moveBlobFiles()) await store.compact();
+	const [{ EngineServer }, { createHyperEndpoint }] = await Promise.all([import("./server-Cd1dLOB8.js"), import("./endpoint-Cl3cgAYl.js")]);
 	const network = hyperdhtNetwork();
 	const dht = mainlineNetwork();
-	const mainline = dht.off ? null : new (await (import("./mainline-Cld-bKeC.js"))).Mainline({
+	const mainline = dht.off ? null : new (await (import("./mainline-CsG-DdJ5.js"))).Mainline({
 		bootstrap: dht.bootstrap,
 		host: dht.host
 	});
-	const transport = mainline || pinned ? new (await (import("./mainline-Cld-bKeC.js"))).RelaysAndDht(mainline, pinned ? { relays: pinned } : {}, !!pinned) : null;
+	const transport = mainline || pinned ? new (await (import("./mainline-CsG-DdJ5.js"))).RelaysAndDht(mainline, pinned ? { relays: pinned } : {}, !!pinned) : null;
 	const apps = servedApps(paths.dir).length > 0;
 	const server = new EngineServer({
 		...transport ? { transport } : {},
@@ -4645,7 +4766,7 @@ async function startRuntime(paths, options = {}) {
 		callsUnavailable,
 		apps,
 		close: () => closing ??= (async () => {
-			await server.node.shutdown().catch(() => {});
+			await server.node.shutdown({ quitting: true }).catch(() => {});
 			await mainline?.destroy().catch(() => {});
 			await store.close();
 		})()
@@ -4849,6 +4970,7 @@ function connection(ctx, socket, secret) {
 		input: socket,
 		crlfDelay: Infinity
 	});
+	lines.on("error", () => {});
 	let buffered = 0;
 	socket.on("data", (chunk) => {
 		buffered += chunk.length;
@@ -4945,4 +5067,4 @@ function connection(ctx, socket, secret) {
 //#endregion
 export { BASELINE_NEWEST, MAX_LINE, MAX_UNREAD, keepServing, openHost, serve };
 
-//# sourceMappingURL=host-DPy0eaH9.js.map
+//# sourceMappingURL=host-Drd-c4VO.js.map