wire-mesh-core 4.1.5 → 4.2.1

package/dist/domain/fault-report.mjs

@@ -0,0 +1,129 @@
+import { t as unrefIfSupported } from "../timers-Q1_kDTyY.mjs";
+//#region src/domain/fault-report.ts
+/** The shortest time between two reports for one source. */
+const FAULT_REPORT_INTERVAL_MS = 1e3;
+/** The most sources whose report windows are kept at once; past it the oldest window goes, its pending count delivered first if the budget allows. */
+const MAX_TRACKED_FAULT_SOURCES = 1024;
+/** The most reports delivered across all sources in one interval. A source beyond it is counted like one inside its own interval, so the total is bounded however many distinct sources a peer presents. */
+const MAX_FAULT_REPORTS_PER_INTERVAL = 64;
+/** The most characters of a fault's text that a log line or console report carries, since the text can come from what a peer sent. */
+const MAX_FAULT_TEXT_CHARS = 256;
+/** A fault as one bounded, quoted line of text: control characters are escaped, so it cannot start a new line, and it is cut to MAX_FAULT_TEXT_CHARS. */
+function describeFault(error) {
+	return JSON.stringify(String(error).slice(0, 256));
+}
+/** Runs `deliver` so that nothing it does reaches the caller: a throw, or a returned promise that rejects, is reported once to the console and dropped. */
+function deliverContained(deliver, suppressed) {
+	const report = (error) => {
+		console.error(`the fault callback failed: ${describeFault(error)}`);
+	};
+	try {
+		const result = deliver(suppressed);
+		if (typeof result === "object" && result !== null && "then" in result && typeof result.then === "function") Promise.resolve(result).catch(report);
+	} catch (error) {
+		report(error);
+	}
+}
+/** A clock that never steps backwards, which the interval arithmetic relies on. */
+function monotonicNow() {
+	return performance.now();
+}
+/**
+* Builds a reporter that delivers a source's first fault at once and then at most one more per FAULT_REPORT_INTERVAL_MS, with at most MAX_FAULT_REPORTS_PER_INTERVAL reports across all sources. A fault inside a source's interval is counted, and the most recent one is delivered when the interval ends, carrying the count of the others; a source that falls quiet is therefore still told. Each report's `suppressed` counts the faults of its source that were not reported before it, not the one it carries.
+*
+* A source forgotten to keep the number of tracked sources bounded loses nothing silently: the faults it still had pending are added to the count the next delivered report carries, from whichever source.
+*
+* `now` is the clock the intervals are read from; it must not step backwards.
+*/
+function createFaultReporter(now = monotonicNow) {
+	const windows = /* @__PURE__ */ new Map();
+	const budget = {
+		since: Number.NEGATIVE_INFINITY,
+		used: 0
+	};
+	const forgotten = { count: 0 };
+	/** Takes one report from the interval's budget, if it has one left. */
+	function admit(at) {
+		if (at - budget.since >= 1e3) {
+			budget.since = at;
+			budget.used = 0;
+		}
+		if (budget.used >= 64) return false;
+		budget.used += 1;
+		return true;
+	}
+	/** What a delivered report adds for faults of sources that were forgotten, which it takes over. */
+	function takeForgotten() {
+		const count = forgotten.count;
+		forgotten.count = 0;
+		return count;
+	}
+	function arm(source) {
+		const window = windows.get(source);
+		if (window === void 0 || window.timer !== void 0) return;
+		const delay = Math.max(0, window.since + FAULT_REPORT_INTERVAL_MS - now());
+		const timer = setTimeout(() => {
+			flush(source);
+		}, delay);
+		unrefIfSupported(timer);
+		window.timer = timer;
+	}
+	/** Delivers a window's most recent pending fault at the end of its interval, or waits for the next interval when the budget is spent. */
+	function flush(source) {
+		const window = windows.get(source);
+		if (window === void 0) return;
+		window.timer = void 0;
+		const { latest } = window;
+		if (window.pending === 0 || latest === void 0) return;
+		const at = now();
+		window.since = at;
+		if (!admit(at)) {
+			arm(source);
+			return;
+		}
+		const others = window.pending - 1;
+		window.pending = 0;
+		window.latest = void 0;
+		deliverContained(latest, others + takeForgotten());
+	}
+	function forgetOldest() {
+		const oldest = windows.entries().next();
+		if (oldest.done === true) return;
+		const [source, window] = oldest.value;
+		clearTimeout(window.timer);
+		windows.delete(source);
+		forgotten.count += window.pending;
+	}
+	return (source, deliver) => {
+		const at = now();
+		const window = windows.get(source);
+		if (window !== void 0 && at - window.since < 1e3) {
+			window.pending += 1;
+			window.latest = deliver;
+			arm(source);
+			return;
+		}
+		const carried = window?.pending ?? 0;
+		clearTimeout(window?.timer);
+		windows.delete(source);
+		const next = {
+			since: at,
+			pending: carried,
+			latest: window?.latest,
+			timer: void 0
+		};
+		windows.set(source, next);
+		if (windows.size > 1024) forgetOldest();
+		if (!admit(at)) {
+			next.pending += 1;
+			next.latest = deliver;
+			arm(source);
+			return;
+		}
+		next.pending = 0;
+		next.latest = void 0;
+		deliverContained(deliver, carried + takeForgotten());
+	};
+}
+//#endregion
+export { FAULT_REPORT_INTERVAL_MS, MAX_FAULT_REPORTS_PER_INTERVAL, MAX_FAULT_TEXT_CHARS, MAX_TRACKED_FAULT_SOURCES, createFaultReporter, deliverContained, describeFault };

package/dist/domain/gossip-expansion.cjs

@@ -43,7 +43,7 @@ function createGossipExpansion(options) {
 		expand({
 			device: advert.device,
 			addresses: advert.addresses
-		});
+		}).catch(() => void 0);
 	} };
 }
 //#endregion

package/dist/domain/gossip-expansion.d.cts

@@ -1,5 +1,5 @@
 import { D as DeviceId, et as PeerAdvert } from "../protocol-Cb3BnuTL.cjs";
-import { MeshSession } from "./mesh-session.cjs";
+import { p as MeshSession } from "../mesh-session-By06Mnu-.cjs";
 //#region src/domain/gossip-expansion.d.ts
 /** One not-yet-considered device this session's gossip directory has surfaced, carrying only what a dial/trust decision needs: the device-id to decide identity, and the "host:port" addresses its own peer-advert claims are directly reachable at, in the order it advertised them. */
 export interface GossipExpansionCandidate {

package/dist/domain/gossip-expansion.d.mts

@@ -1,5 +1,5 @@
 import { D as DeviceId, et as PeerAdvert } from "../protocol-Cb3BnuTL.mjs";
-import { MeshSession } from "./mesh-session.mjs";
+import { p as MeshSession } from "../mesh-session-DzcZYdhe.mjs";
 //#region src/domain/gossip-expansion.d.ts
 /** One not-yet-considered device this session's gossip directory has surfaced, carrying only what a dial/trust decision needs: the device-id to decide identity, and the "host:port" addresses its own peer-advert claims are directly reachable at, in the order it advertised them. */
 export interface GossipExpansionCandidate {

package/dist/domain/gossip-expansion.mjs

@@ -42,7 +42,7 @@ function createGossipExpansion(options) {
 		expand({
 			device: advert.device,
 			addresses: advert.addresses
-		});
+		}).catch(() => void 0);
 	} };
 }
 //#endregion

package/dist/domain/grant-candidates.d.cts

@@ -1,5 +1,5 @@
 import { D as DeviceId, f as CapabilityScope } from "../protocol-Cb3BnuTL.cjs";
-import { DirectoryEntry, MeshSession } from "./mesh-session.cjs";
+import { a as DirectoryEntry, p as MeshSession } from "../mesh-session-By06Mnu-.cjs";
 import { z } from "zod";
 //#region src/domain/grant-candidates.d.ts
 declare const grantCandidateSchema: z.ZodObject<{

package/dist/domain/grant-candidates.d.mts

@@ -1,5 +1,5 @@
 import { D as DeviceId, f as CapabilityScope } from "../protocol-Cb3BnuTL.mjs";
-import { DirectoryEntry, MeshSession } from "./mesh-session.mjs";
+import { a as DirectoryEntry, p as MeshSession } from "../mesh-session-DzcZYdhe.mjs";
 import { z } from "zod";
 //#region src/domain/grant-candidates.d.ts
 declare const grantCandidateSchema: z.ZodObject<{