@ghostlytools/cli 1.3.9 → 1.3.10

package/dist/assets/bark_ffi_wasm_bg-EY2uc0Bx.js.map

@@ -1 +1 @@
-{"version":3,"file":"bark_ffi_wasm_bg-EY2uc0Bx.js","names":["import.meta.ROLLDOWN_FILE_URL_WPGYjwIlzWVNM1bYhOc83w"],"sources":["../../../../node_modules/@secondts/bark/web/bark_ffi_wasm_bg.wasm?url"],"sourcesContent":["export default import.meta.ROLLDOWN_FILE_URL_WPGYjwIlzWVNM1bYhOc83w"],"ignoreList":[0],"mappings":";AAAA,IAAA,2BAAe,IAAA,IAAA,oCAAA,YAAA,GAAmD,CAAA,CAAnDA"}
+{"version":3,"file":"bark_ffi_wasm_bg-EY2uc0Bx.js","names":["import.meta.ROLLDOWN_FILE_URL_FKNdLzKnlftW3t_gzo81yw"],"sources":["../../../../node_modules/@secondts/bark/web/bark_ffi_wasm_bg.wasm?url"],"sourcesContent":["export default import.meta.ROLLDOWN_FILE_URL_FKNdLzKnlftW3t_gzo81yw"],"ignoreList":[0],"mappings":";AAAA,IAAA,2BAAe,IAAA,IAAA,oCAAA,YAAA,GAAmD,CAAA,CAAnDA"}

package/dist/assets/bitcoindevkit_bg-B-iLWrmX.js.map

@@ -1 +1 @@
-{"version":3,"file":"bitcoindevkit_bg-B-iLWrmX.js","names":["import.meta.ROLLDOWN_FILE_URL_FKNdLzKnlftW3t_gzo81yw"],"sources":["../../../../node_modules/@bitcoindevkit/bdk-wallet-web/bitcoindevkit_bg.wasm?url"],"sourcesContent":["export default import.meta.ROLLDOWN_FILE_URL_FKNdLzKnlftW3t_gzo81yw"],"ignoreList":[0],"mappings":";AAAA,IAAA,2BAAe,IAAA,IAAA,oCAAA,YAAA,GAAmD,CAAA,CAAnDA"}
+{"version":3,"file":"bitcoindevkit_bg-B-iLWrmX.js","names":["import.meta.ROLLDOWN_FILE_URL_WPGYjwIlzWVNM1bYhOc83w"],"sources":["../../../../node_modules/@bitcoindevkit/bdk-wallet-web/bitcoindevkit_bg.wasm?url"],"sourcesContent":["export default import.meta.ROLLDOWN_FILE_URL_WPGYjwIlzWVNM1bYhOc83w"],"ignoreList":[0],"mappings":";AAAA,IAAA,2BAAe,IAAA,IAAA,oCAAA,YAAA,GAAmD,CAAA,CAAnDA"}

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

@@ -3397,6 +3397,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 +3569,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 +3915,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 +4027,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 = [];
@@ -4601,7 +4700,7 @@ async function startRuntime(paths, options = {}) {
 	(await import("./ghostly_iroh_web-BsAEFIjl.js")).initSync({ module: irohWasmBytes() });
 	const [{ registerFileBytes }, { NodeFileBytes }] = await Promise.all([import("./fileBytes-CgbibpbV.js"), import("./fileBytes-CfSXjTFa.js")]);
 	registerFileBytes("native", async () => new NodeFileBytes(paths.files), true);
-	const [{ EngineServer }, { createHyperEndpoint }] = await Promise.all([import("./server-p5DJnN7T.js"), import("./endpoint-BOTFMpfS.js")]);
+	const [{ EngineServer }, { createHyperEndpoint }] = await Promise.all([import("./server-C-EkLCCt.js"), import("./endpoint-BOTFMpfS.js")]);
 	const network = hyperdhtNetwork();
 	const dht = mainlineNetwork();
 	const mainline = dht.off ? null : new (await (import("./mainline-Cld-bKeC.js"))).Mainline({
@@ -4945,4 +5044,4 @@ function connection(ctx, socket, secret) {
 //#endregion
 export { BASELINE_NEWEST, MAX_LINE, MAX_UNREAD, keepServing, openHost, serve };
 
-//# sourceMappingURL=host-DPy0eaH9.js.map
+//# sourceMappingURL=host-BbDWamRc.js.map