@midsummer-ai/sdk 0.0.0-stage → 0.1.0-next.419

package/connection-CDk7H1FL.mjs

@@ -0,0 +1,1871 @@
+//#region src/database/client/policy.mjs
+/** The platform's prices in USD, per unit named: an object request, a WebSocket message (billed 20:1 as requests), a SQL row
+*  written, an object awake second (128 MB at $12.50 per million GB-s), a server CPU ms, a server request. And two
+*  MEASURED costs in CPU ms, not USD: `relayCpuMs` a relayed op (in and its
+*  answer), `pushCpuMs` a push. */
+const PRICES = {
+	objectRequest: 15e-8,
+	wsMsg: 15e-8 / 20,
+	row: 1e-6,
+	awakeSec: 15625e-10,
+	serverCpuMs: 2e-8,
+	serverRequest: 3e-7,
+	relayCpuMs: .217,
+	pushCpuMs: .156
+};
+const LN2 = Math.log(2);
+const fin = (x, fallback) => Number.isFinite(x) ? x : fallback;
+/** An event rate in events per second, an EWMA with a half-life: a steady stream of r events/s reads r; after the
+*  stream stops the rate halves every `halfLifeMs`. `add(n, now)` records n events; `perSec(now)` reads the rate. */
+var Rate = class {
+	constructor(halfLifeMs = 5e3) {
+		this.halfLifeMs = Math.max(1, fin(halfLifeMs, 5e3));
+		this.lambda = LN2 / (this.halfLifeMs / 1e3);
+		this.v = 0;
+		this.at = null;
+	}
+	/** The decayed value at `now` (a clock that steps back counts as no time passed). */
+	#at(now) {
+		return this.at === null ? 0 : this.v * Math.exp(-this.lambda * Math.max(0, now - this.at) / 1e3);
+	}
+	add(n = 1, now = Date.now()) {
+		this.v = this.#at(now) + fin(n, 0) * this.lambda;
+		this.at = this.at === null ? now : Math.max(this.at, now);
+		return this;
+	}
+	perSec(now = Date.now()) {
+		return this.#at(now);
+	}
+};
+/** A2: the ski-rental break-even, in ms to keep a thing held after its last use. Holding costs `holdUsdPerSec`;
+*  letting go costs `eachUsd` the next time it is needed (a wake, a reconnect, a request billed instead of a message).
+*  The deterministic break-even is eachUsd / holdUsdPerSec (never more than twice the cost of the best choice made in
+*  hindsight). With an observed `ratePerSec`, hold only while holding costs less than paying per event at that rate
+*  (holdUsdPerSec < eachUsd * ratePerSec): then keep the break-even, else let go at once (0). Holding for free:
+*  Infinity; an event for free: 0. */
+function breakEvenMs({ holdUsdPerSec, eachUsd, ratePerSec } = {}) {
+	const hold = fin(holdUsdPerSec, 0), each = fin(eachUsd, 0);
+	if (each <= 0) return 0;
+	if (hold <= 0) return Infinity;
+	const ms = each / hold * 1e3;
+	if (ratePerSec === void 0 || ratePerSec === null) return ms;
+	return hold < each * fin(ratePerSec, 0) ? ms : 0;
+}
+/** A1: the hybrid histogram keep-alive policy. `gap(ms)` records an idle gap between two uses, in `bins` bins of
+*  `binMs` (gaps past the last bin count as out of range). Once `minSamples` gaps are in and the histogram is
+*  PATTERNED (the bin counts' coefficient of variation is at least `cv`, and at most half the gaps are out of range),
+*  `keepMs()` is the gap's 99th percentile (the bin's upper edge, plus `margin`) and `prewarmMs()` its 5th percentile
+*  (the bin's lower edge, less `margin`; null when that is 0: no point letting go). Otherwise `keepMs()` is
+*  `fallbackMs` (pass the break-even, A2) and `prewarmMs()` null. Every `halfAt` gaps the counts are halved, so the
+*  histogram follows a changing pattern. A pre-wake needs a timer: the database sets none while idle, so a caller uses
+*  `prewarmMs` only where it already holds one (or an alarm). */
+var KeepAlive = class {
+	constructor({ binMs = 1e3, bins = 240, minSamples = 20, fallbackMs = 1e4, cv = 2, margin = .1, halfAt = 1e4 } = {}) {
+		this.binMs = Math.max(1, fin(binMs, 1e3));
+		this.bins = Math.max(1, Math.floor(fin(bins, 240)));
+		this.minSamples = Math.max(1, fin(minSamples, 20));
+		this.fallbackMs = fin(fallbackMs, 1e4);
+		this.cv = fin(cv, 2);
+		this.margin = Math.min(.9, Math.max(0, fin(margin, .1)));
+		this.halfAt = Math.max(2, fin(halfAt, 1e4));
+		this.counts = new Float64Array(this.bins);
+		this.inRange = 0;
+		this.oob = 0;
+		this.memo = null;
+	}
+	/** Records one idle gap (ms between the end of a use and the next use). */
+	gap(ms) {
+		if (!Number.isFinite(ms) || ms < 0) return this;
+		const b = Math.floor(ms / this.binMs);
+		if (b < this.bins) {
+			this.counts[b] += 1;
+			this.inRange += 1;
+		} else this.oob += 1;
+		if (this.inRange + this.oob >= this.halfAt) {
+			for (let k = 0; k < this.bins; k += 1) this.counts[k] /= 2;
+			this.inRange /= 2;
+			this.oob /= 2;
+		}
+		this.memo = null;
+		return this;
+	}
+	/** The gaps seen (after halving), and whether the histogram is patterned; p5 / p99 bins when it is. */
+	shape() {
+		if (this.memo) return this.memo;
+		const total = this.inRange + this.oob;
+		let memo = {
+			samples: total,
+			patterned: false,
+			cv: 0,
+			p5: null,
+			p99: null
+		};
+		if (total >= this.minSamples && this.inRange > 0 && this.oob <= total / 2) {
+			const mean = this.inRange / this.bins;
+			let sq = 0;
+			for (let k = 0; k < this.bins; k += 1) sq += (this.counts[k] - mean) ** 2;
+			const cv = Math.sqrt(sq / this.bins) / mean;
+			const at = (p) => {
+				const want = p * total;
+				let acc = 0;
+				for (let k = 0; k < this.bins; k += 1) {
+					acc += this.counts[k];
+					if (acc >= want) return k;
+				}
+				return null;
+			};
+			const p5 = at(.05), p99 = at(.99);
+			memo = {
+				samples: total,
+				patterned: cv >= this.cv && p99 !== null,
+				cv,
+				p5,
+				p99
+			};
+		}
+		this.memo = memo;
+		return memo;
+	}
+	/** How long to stay warm or held after the last use. */
+	keepMs() {
+		const s = this.shape();
+		return s.patterned ? Math.ceil((s.p99 + 1) * this.binMs * (1 + this.margin)) : this.fallbackMs;
+	}
+	/** When to pre-wake after the last use, or null (not patterned, or the next use usually comes at once). */
+	prewarmMs() {
+		const s = this.shape();
+		if (!s.patterned) return null;
+		const ms = Math.floor(s.p5 * this.binMs * (1 - this.margin));
+		return ms > 0 ? ms : null;
+	}
+};
+/** A3: additive increase, multiplicative decrease (Clipper's batch sizing): `observe(latencyMs)` raises the value by
+*  `add` while the latency is at or under `targetMs` and multiplies it by `mult` above it, clamped to [min, max].
+*  The value is a number (round it where a count is needed). */
+var Aimd = class {
+	constructor({ targetMs, min = 0, max = 1e3, add = 1, mult = .5, start = min } = {}) {
+		if (!Number.isFinite(targetMs)) throw new RangeError("Aimd: targetMs");
+		if (!(min <= max)) throw new RangeError("Aimd: min > max");
+		Object.assign(this, {
+			targetMs,
+			min,
+			max,
+			add,
+			mult
+		});
+		this.v = Math.min(max, Math.max(min, fin(start, min)));
+	}
+	observe(latencyMs) {
+		if (!Number.isFinite(latencyMs)) return this.v;
+		this.v = latencyMs <= this.targetMs ? Math.min(this.max, this.v + this.add) : Math.max(this.min, this.v * this.mult);
+		return this.v;
+	}
+	value() {
+		return this.v;
+	}
+};
+/** Decorrelated jitter (AWS, "Exponential Backoff And Jitter"): the next wait after `prev` ms is uniform between
+*  `base` and 3x `prev` (at least `base`), at most `cap`. `rand`: a [0, 1) source (tests pass their own). */
+function jitterBackoff(prev, base, cap, rand = Math.random) {
+	const lo = Math.max(0, fin(base, 0)), hi = Math.max(lo, fin(prev, 0) * 3);
+	return Math.min(fin(cap, Infinity), lo + rand() * (hi - lo));
+}
+const TAG_TTL = 864e5;
+const groupOf = (id) => {
+	const t = String(id ?? ""), k = t.indexOf("/");
+	return k < 0 ? t : t.slice(0, k);
+};
+const unitIn = (dir, id) => {
+	const h = fnv(groupOf(id));
+	for (const u of dir.units) if (h % 2 ** u.d === u.p) return u.name;
+	return dir.units[0]?.name ?? "0";
+};
+const fnv = (id) => {
+	let h = 2166136261;
+	for (let i = 0; i < id.length; i += 1) h = Math.imul(h ^ id.charCodeAt(i), 16777619) >>> 0;
+	return h;
+};
+/** A row id the map puts on unit `name` (`~0`, `~1`, ...: a lane's `home`), or null. */
+const rowOn = (dir, name) => {
+	for (let k = 0; k < 65536; k += 1) if (unitIn(dir, `~${k}`) === name) return `~${k}`;
+	return null;
+};
+/** A token's payload (not verified here: the server does that): a JWT's second part (the platform's, `header.payload.sig`),
+*  or the first of our own (`payload.sig`). Null when it is neither. */
+const payloadOf = (token) => {
+	try {
+		const parts = String(token).split(".");
+		return JSON.parse(atob(parts[parts.length === 3 ? 1 : 0].replace(/-/gu, "+").replace(/_/gu, "/")));
+	} catch {
+		return null;
+	}
+};
+/** A token's `exp` (seconds). */
+const expOf = (token) => payloadOf(token)?.exp ?? null;
+/** An answer the caller must see as a failure: an Error whose `code` is `denied`, `short`, ... (`answer`: the answer). */
+const coded = (a) => Object.assign(new Error(a.err ?? a.why ?? "failed"), {
+	code: a.err ?? a.why ?? "failed",
+	answer: a
+});
+const refused = (a) => ["denied", "short"].includes(a.err ?? a.why);
+/** (dd) Ops that only read (a get, a range, a query function, the map): sent again after a reconnect or a lost link,
+*  never answered `closed` (a deploy resets every edge: a read in flight must not fail for it; reading twice is harmless). */
+const READ_OPS = /* @__PURE__ */ new Set([
+	"g",
+	"r",
+	"f",
+	"q",
+	"dir"
+]);
+/** Who tagged a write: the tag's part before its last `:` (a Connection's client id, or a tab's id). */
+const originOf = (tag) => {
+	const t = String(tag), k = t.lastIndexOf(":");
+	return k < 0 ? t : t.slice(0, k);
+};
+/** Ms an unsubscribe waits for a message to its unit to ride before it goes alone; ms of nothing sent or heard
+*  before a keepalive ping; ms ops wait for the hello's map when none is known. */
+const LEAVE_MS = 1e3;
+const IDLE_PING_MS = 5e4;
+const HELLO_WAIT_MS = 2e3;
+/** A push's cost and a read's (the server CPU of each; a read is also a message the client sends). */
+const PUSH_USD = PRICES.pushCpuMs * PRICES.serverCpuMs;
+const READ_USD = PRICES.wsMsg + PRICES.relayCpuMs * PRICES.serverCpuMs;
+/** The window in which `subscribeAfter` reads of a row subscribe it: the break-even of holding a quiet row (a
+*  push a minute) against reading it again (~227 s), the same rule that lets it go (`quiet`). Was 1 s: a client
+*  reading a row every few seconds paid a message a read for ever (s19: 0 of 28k reads answered here). */
+const SUBSCRIBE_WINDOW_MS = breakEvenMs({
+	holdUsdPerSec: PUSH_USD / 60,
+	eachUsd: READ_USD
+});
+/** Whether a token says server code: ours with `ro: "server"`, or the platform's for a Database Key (`iss: "midsummer"`,
+*  `sub: "key:<id>"`; a person's, `user:<handle>`, is not). */
+const serverToken = (token) => {
+	const p = payloadOf(token);
+	return p?.ro === "server" || p?.iss === "midsummer" && String(p?.sub ?? "").startsWith("key:");
+};
+/** The shape `Connection.connect` takes: "binding" (a server object binding in `opts.env.DATABASE_EDGE` or
+*  `opts.binding`), "server" (a runtime with no `window` / `document`, and a server token), else "browser". `g`: the
+*  globals to look at (tests pass their own). */
+function shapeOf(opts = {}, g = globalThis) {
+	if (opts.shape) return opts.shape;
+	if (opts.binding || opts.env?.DATABASE_EDGE) return "binding";
+	const ua = String(g.navigator?.userAgent ?? "");
+	return !(typeof g.window !== "undefined" || typeof g.document !== "undefined" || /^Mozilla\//u.test(ua) && !g.process?.versions?.node && !g.Deno && !g.Bun) && serverToken(opts.token) ? "server" : "browser";
+}
+/** A row's key in the row copies: `tb/id`, and the acting user's when a server acts as one (rules differ). */
+const rowKey = (tb, id, as) => as === void 0 ? `${tb}/${id}` : `${tb}/${id}@${as}`;
+const asOf = (as) => as === void 0 || as === null ? {} : { as: String(as) };
+/** A server function named by its reference (`api.pay`: `{ name, kind }`, the seal's functions/_generated/api.mjs) or its name. */
+const fnName = (f) => f !== null && typeof f === "object" && typeof f.name === "string" ? f.name : f;
+/** The process's server sockets: url|token -> the Connection (one socket per process, however often connected). */
+const SHARED = /* @__PURE__ */ new Map();
+/** (A11) W-TinyLFU: which keys a bounded cache keeps. New keys enter a small window LRU (1%); a key leaving the
+*  window is admitted to the main LRU only if a count-min sketch (4 rows of 4-bit-ish counters, halved every 10x the
+*  size in accesses) says it is used more often than the main LRU's victim. `touch` every access (hit or miss), `add`
+*  a missed key: it returns the keys that left the cache (possibly the one leaving the window). */
+var TinyLfu = class {
+	constructor(size, { windowShare = .01 } = {}) {
+		this.size = Math.max(2, Math.floor(size));
+		this.wcap = Math.max(1, Math.round(this.size * windowShare));
+		this.mcap = this.size - this.wcap;
+		this.window = /* @__PURE__ */ new Map();
+		this.main = /* @__PURE__ */ new Map();
+		const width = 2 ** Math.ceil(Math.log2(Math.max(16, this.size * 4)));
+		this.width = width;
+		this.mask = width - 1;
+		this.sketch = new Uint8Array(width * 4);
+		this.samples = 0;
+		this.resetAt = 10 * this.size;
+	}
+	slots(key) {
+		const h1 = fnv(key), h2 = Math.imul(h1 ^ h1 >>> 16, 2246822507) >>> 0 | 1;
+		return [
+			0,
+			1,
+			2,
+			3
+		].map((r) => r * this.width + (h1 + Math.imul(r, h2) >>> 0 & this.mask));
+	}
+	freq(key) {
+		let f = 15;
+		for (const s of this.slots(key)) f = Math.min(f, this.sketch[s]);
+		return f;
+	}
+	touch(key) {
+		for (const s of this.slots(key)) if (this.sketch[s] < 15) this.sketch[s] += 1;
+		if ((this.samples += 1) >= this.resetAt) {
+			this.samples /= 2;
+			for (let k = 0; k < this.sketch.length; k += 1) this.sketch[k] >>= 1;
+		}
+		if (this.window.has(key)) {
+			this.window.delete(key);
+			this.window.set(key, 1);
+		} else if (this.main.has(key)) {
+			this.main.delete(key);
+			this.main.set(key, 1);
+		}
+	}
+	has(key) {
+		return this.window.has(key) || this.main.has(key);
+	}
+	get count() {
+		return this.window.size + this.main.size;
+	}
+	add(key) {
+		if (this.has(key)) return [];
+		this.window.set(key, 1);
+		if (this.window.size <= this.wcap) return [];
+		const cand = this.window.keys().next().value;
+		this.window.delete(cand);
+		if (this.main.size < this.mcap) {
+			this.main.set(cand, 1);
+			return [];
+		}
+		const victim = this.main.keys().next().value;
+		if (this.freq(cand) > this.freq(victim)) {
+			this.main.delete(victim);
+			this.main.set(cand, 1);
+			return [victim];
+		}
+		return [cand];
+	}
+	delete(key) {
+		this.window.delete(key);
+		this.main.delete(key);
+	}
+};
+var Connection = class Connection {
+	/** Opens the database in the shape of where it runs (see the top of this file). */
+	static async connect(url, options = {}) {
+		const shape = shapeOf(options);
+		if (shape === "binding") throw Object.assign(/* @__PURE__ */ new Error("connect over the network with a server token: a binding is not part of this client"), { code: "binding" });
+		if (shape === "server") {
+			const key = `${url}|${options.token ?? ""}`;
+			let p = SHARED.get(key);
+			if (!p) {
+				p = Connection.open(url, {
+					...options,
+					shape
+				}).then((g) => {
+					g.sharedKey = key;
+					return g;
+				}, (e) => {
+					SHARED.delete(key);
+					throw e;
+				});
+				SHARED.set(key, p);
+			}
+			const g = await p;
+			g.refs += 1;
+			return g;
+		}
+		const o = {
+			...options,
+			shape
+		};
+		if (o.store === void 0 && typeof indexedDB !== "undefined" && typeof document !== "undefined") o.store = (await import("./store-BzI9at5x.mjs")).idbStore(new URL(url).host);
+		if (o.tabs !== false && typeof document !== "undefined") return (await import("./tabs-D-P8_ci_.mjs")).ConnectionTabs.connect(url, o);
+		return Connection.open(url, o);
+	}
+	/** A Connection over one socket, of the shape given (default "browser"), no detection (tabs.mjs opens its own so). */
+	static async open(url, options) {
+		const g = new Connection(url, options);
+		if (g.store) await g.store.attach(g);
+		if (options.functions) g.predictor = new (await (import("./predict-Drfm_8pO.mjs"))).Predictor(g, options.functions);
+		await g.open();
+		if (!g.dir) await Promise.race([g.hello, new Promise((r) => setTimeout(r, HELLO_WAIT_MS))]);
+		return g;
+	}
+	constructor(url, { token = "", refresh = null, home = "", store = null, silent = 3e3, window = null, budgetMs = 5, cacheRows = 256, subscribeAfter = 3, subscribeWindowMs = SUBSCRIBE_WINDOW_MS, shape = "browser", dial = null, lanes = false }) {
+		this.silent = silent;
+		this.shape = shape;
+		this.dial = dial;
+		this.durable = shape !== "browser";
+		this.refs = 0;
+		this.window = window ?? null;
+		this.lastFlush = -Infinity;
+		this.gather = null;
+		this.aimd = new Aimd({
+			targetMs: budgetMs / 2,
+			min: 0,
+			max: budgetMs,
+			add: budgetMs / 10,
+			mult: .5
+		});
+		this.dur = null;
+		this.conflating = /* @__PURE__ */ new Map();
+		this.conflateTimer = null;
+		this.conflateAimd = new Aimd({
+			targetMs: 100,
+			min: 50,
+			max: 100,
+			add: 5,
+			mult: .5,
+			start: 50
+		});
+		this.leaving = /* @__PURE__ */ new Map();
+		this.leaveTimer = null;
+		this.lastSent = -Infinity;
+		this.helloSeen = false;
+		this.subscribeAfter = subscribeAfter;
+		this.subscribeWindowMs = subscribeWindowMs;
+		this.lfu = new TinyLfu(cacheRows);
+		this.auto = /* @__PURE__ */ new Map();
+		this.heat = /* @__PURE__ */ new Map();
+		this.never = /* @__PURE__ */ new Set();
+		this.keep = new KeepAlive({
+			binMs: 100,
+			bins: 600,
+			minSamples: 20
+		});
+		this.store = store;
+		this.predictor = null;
+		this.base = url.replace(/^ws/u, "http");
+		this.token = token;
+		this.refresh = refresh;
+		this.qs = home ? `&home=${encodeURIComponent(home)}` : "";
+		this.lanes = lanes && !dial ? /* @__PURE__ */ new Map() : null;
+		this.esc = null;
+		this.hello = new Promise((r) => {
+			this.helloed = r;
+		});
+		this.unconfirmed = /* @__PURE__ */ new Map();
+		this.sentMsgs = /* @__PURE__ */ new Map();
+		this.durTimes = [];
+		this.units = 1;
+		this.client = Math.random().toString(36).slice(2, 10);
+		this.next = 0;
+		this.tags = 0;
+		this.waiting = /* @__PURE__ */ new Map();
+		this.outbox = /* @__PURE__ */ new Map();
+		this.held = [];
+		this.reads = /* @__PURE__ */ new Map();
+		this.rows = /* @__PURE__ */ new Map();
+		this.mine = /* @__PURE__ */ new Map();
+		this.overlay = /* @__PURE__ */ new Map();
+		this.watches = /* @__PURE__ */ new Map();
+		this.byI = /* @__PURE__ */ new Map();
+		this.closed = false;
+		this.dir = null;
+		this.dirListeners = /* @__PURE__ */ new Set();
+		this.stats = {
+			messages: 0,
+			ops: 0,
+			localReads: 0,
+			sharedReads: 0,
+			sharedWatches: 0,
+			pushes: 0,
+			outOfOrder: 0,
+			resent: 0,
+			reconnects: 0,
+			moved: 0,
+			maps: 0,
+			conflated: 0,
+			autoSubs: 0,
+			autoDrops: 0,
+			pings: 0,
+			unsubs: 0,
+			unsubsRode: 0,
+			rewatched: 0
+		};
+	}
+	unitOf(id = "") {
+		return this.dir ? unitIn(this.dir, id) : String(fnv(groupOf(id)) % this.units);
+	}
+	unitNames() {
+		return this.dir ? this.dir.units.map((u) => u.name) : Array.from({ length: this.units }, (_, k) => String(k));
+	}
+	setDir(dir) {
+		if (dir && (!this.dir || dir.v > this.dir.v)) {
+			this.dir = dir;
+			this.stats.maps += 1;
+			for (const f of [...this.dirListeners]) f();
+		}
+	}
+	/** Asks the edge for the director's map (one question in flight). */
+	refreshDir() {
+		this.dirAsk ??= this.send("*", { k: "dir" }).then((a) => {
+			this.dirAsk = null;
+			if (a.ok) this.setDir(a.dir);
+		});
+		return this.dirAsk;
+	}
+	/** The socket's URL with the current token. */
+	get url() {
+		return `${this.base.replace(/^http/u, "ws")}/ws?token=${encodeURIComponent(this.token)}${this.qs}`;
+	}
+	/** The token as query parameters, for the HTTP routes. */
+	auth() {
+		return `token=${encodeURIComponent(this.token)}`;
+	}
+	/** Opens the socket; a refused open (401: the token expired or is bad) gets a new token from `refresh` and tries once
+	*  more. Every token is renewed 60 s before its `exp`. */
+	async open() {
+		this.renewAt();
+		try {
+			await this.openOnce();
+		} catch (e) {
+			if (!await this.denied()) throw e;
+			await this.renew(false);
+			await this.openOnce();
+		}
+	}
+	/** Whether a failed open was a 401: an expiring token is, else the same URL over HTTP is asked (the server checks the
+	*  token before anything; a browser's WebSocket never shows the status). */
+	async denied() {
+		if (!this.refresh) return false;
+		const exp = expOf(this.token);
+		if (!this.token || exp && exp * 1e3 - Date.now() < 6e4) return true;
+		try {
+			return (await fetch(this.url.replace(/^ws/u, "http"), { signal: AbortSignal.timeout(1e4) })).status === 401;
+		} catch {
+			return false;
+		}
+	}
+	/** A new token from `refresh`; `reopen`: the socket closes, and the reconnect (resend, resubscribe) uses it. */
+	async renew(reopen = true) {
+		this.renewing ??= Promise.resolve(this.refresh()).then((t) => {
+			this.token = t;
+			this.renewAt();
+		}).finally(() => {
+			this.renewing = null;
+		});
+		await this.renewing;
+		if (reopen) this.drop("renew");
+	}
+	renewAt() {
+		clearTimeout(this.renewer);
+		const exp = this.refresh && expOf(this.token);
+		if (!exp || this.closed) return;
+		this.renewer = setTimeout(() => this.renew().catch(() => this.renewAt()), Math.max(1e3, exp * 1e3 - Date.now() - 6e4));
+		this.renewer.unref?.();
+	}
+	openOnce() {
+		return new Promise((ready, fail) => {
+			const dialed = this.dial ? Promise.resolve(this.dial(this)) : null;
+			const ws = dialed ? null : new WebSocket(this.url);
+			const timer = setTimeout(() => {
+				fail(/* @__PURE__ */ new Error("open timeout"));
+				try {
+					ws?.close(1e3);
+				} catch {}
+			}, 1e4);
+			const opened = (ws) => {
+				clearTimeout(timer);
+				if (this.closed) {
+					try {
+						ws.close(1e3);
+					} catch {}
+					ready();
+					return;
+				}
+				this.ws = ws;
+				this.heard = this.answeredAt = this.openedAt = performance.now();
+				this.probe = 0;
+				this.stuckSince = 0;
+				this.resend();
+				ready();
+				if (!this.dog) {
+					this.dog = setInterval(() => this.watchdog(), 1e3);
+					this.dog.unref?.();
+				}
+			};
+			if (dialed) {
+				dialed.then((s) => {
+					this.listen(s);
+					opened(s);
+				}, (e) => {
+					clearTimeout(timer);
+					fail(e);
+				});
+				return;
+			}
+			ws.addEventListener("open", () => opened(ws), { once: true });
+			ws.addEventListener("error", () => {
+				if (ws.readyState !== 1) {
+					clearTimeout(timer);
+					fail(/* @__PURE__ */ new Error("socket error"));
+				}
+			});
+			this.listen(ws);
+		});
+	}
+	/** A socket's messages and close (a socket left by `drop` is not heard any more). */
+	listen(ws) {
+		ws.addEventListener("message", (event) => {
+			if (this.ws !== ws) return;
+			this.heard = performance.now();
+			this.probe = 0;
+			if (event.data !== "pong") this.answeredAt = this.heard;
+			this.stats.bytesIn = (this.stats.bytesIn ?? 0) + (event.data.length ?? event.data.byteLength ?? 0);
+			this.received(event.data);
+			if (this.held.length) this.schedule();
+		});
+		ws.addEventListener("close", () => {
+			if (this.ws === ws) {
+				this.ws = null;
+				if (!this.closed) this.reconnect();
+			}
+		});
+	}
+	/** Opens a socket again until one opens (one loop at a time), backing off from `delay` to 5 s. Decorrelated
+	*  jitter (policy `jitterBackoff`): clients a dead edge dropped together do not come back together. */
+	async reconnect(delay = 100) {
+		if (this.reopening || this.closed) return;
+		this.reopening = true;
+		this.stats.reconnects += 1;
+		try {
+			for (;;) {
+				await new Promise((r) => setTimeout(r, delay));
+				if (this.closed || this.ws?.readyState === 1) return;
+				try {
+					await this.open();
+					return;
+				} catch {
+					delay = jitterBackoff(delay, 50, 5e3);
+				}
+			}
+		} finally {
+			this.reopening = false;
+		}
+	}
+	/** Leaves the socket NOW and opens another (resend, resubscribe), without waiting for its close handshake: a socket
+	*  whose close is never answered stays CLOSING for ever, its ops never sent (every user an edge `{move}`d
+	*  stalled, the edge never answering a close without a code). */
+	drop(why) {
+		const ws = this.ws;
+		if (!ws) return;
+		this.ws = null;
+		this.stats.drops = (this.stats.drops ?? 0) + 1;
+		try {
+			ws.close(4e3, why);
+		} catch {}
+		if (!this.closed) this.reconnect(0);
+	}
+	/** WATCHDOG, each second: a socket not open for 2 s, or none and no reconnect going while ops are owed, or an open
+	*  socket SILENT while an op waits (nothing heard `silent` ms after it was sent: a ping goes, and nothing heard for
+	*  `silent` ms more; or pongs but no answer for 5x `silent`) is left and another opened. Everything unanswered goes
+	*  again, same tags: exactly once (a unit answers a repeated tag from its tags). */
+	watchdog() {
+		if (this.closed) return;
+		const now = performance.now(), ws = this.ws, silent = this.silent;
+		const fire = (why) => {
+			this.stats.watchdog = (this.stats.watchdog ?? 0) + 1;
+			if (ws) this.drop(why);
+			else this.reconnect(0);
+		};
+		if (this.lanes) this.laneDog(now);
+		if (!ws) {
+			if (!this.reopening && (this.waiting.size || this.unconfirmed.size || this.outbox.size)) fire("none");
+			return;
+		}
+		if (ws.readyState !== 1) {
+			this.stuckSince ||= now;
+			if (now - this.stuckSince > 2e3) fire("stuck");
+			return;
+		}
+		this.stuckSince = 0;
+		if (!this.dir && !this.helloSeen && now - this.openedAt > HELLO_WAIT_MS) {
+			this.helloSeen = true;
+			if (this.outbox.size) this.schedule();
+		}
+		if (now - Math.max(this.heard, this.lastSent) > IDLE_PING_MS) {
+			this.ping(ws, now);
+			return;
+		}
+		let oldest = Infinity;
+		for (const w of this.waiting.values()) if (w.sentAt < oldest) oldest = w.sentAt;
+		if (!(now - oldest > silent)) {
+			this.probe = 0;
+			return;
+		}
+		if (this.probe ? now - this.probe > silent : now - Math.max(this.answeredAt, oldest) > 5 * silent) {
+			fire("silent");
+			return;
+		}
+		if (!this.probe && now - Math.max(this.heard, oldest) > silent) {
+			this.probe = now;
+			this.ping(ws, now);
+		}
+	}
+	/** A ping (a message the client sends: counted, and it resets the idle clock). */
+	ping(ws, now) {
+		this.lastSent = now;
+		this.stats.pings += 1;
+		try {
+			ws.send("ping");
+		} catch {}
+	}
+	/** After (re)opening: everything unanswered that must land goes again, with its tag; every subscription starts
+	*  again from a fresh snapshot (the new edge knows nothing of the old socket's). */
+	resend() {
+		this.outbox.clear();
+		this.held = [];
+		for (const w of this.leaving.values()) this.gone(w);
+		this.leaving.clear();
+		clearTimeout(this.leaveTimer);
+		this.leaveTimer = null;
+		const again = /* @__PURE__ */ new Set();
+		for (const w of this.waiting.values()) {
+			if (w.sent && !w.keep && !READ_OPS.has(w.op.k)) {
+				this.waiting.delete(w.op.i);
+				w.resolve({
+					i: w.op.i,
+					ok: false,
+					why: "closed"
+				});
+				continue;
+			}
+			if (w.sent) this.stats.resent += 1;
+			w.sentAt = void 0;
+			again.add(w.op.i);
+			this.queue(w.unit, w.op);
+		}
+		for (const [i, u] of this.unconfirmed) if (!again.has(i)) {
+			this.stats.resent += 1;
+			this.waiting.set(i, {
+				unit: u.unit,
+				op: u.op,
+				resolve: () => {},
+				keep: true,
+				sent: false
+			});
+			this.queue(u.unit, u.op);
+		}
+		for (const w of this.watches.values()) if (!again.has(w.i)) this.subscribe(w);
+	}
+	/** Sends an op to a unit with the others of this turn; resolves with its answer. */
+	/** `relax`: a write to an "e" table resolves when first sent (`{ ok: true, sent: true }`; it still lands once,
+	*  same tag, and its answer is still read here); "b" or "e": never waits for durable (server shapes), and its round
+	*  trip tunes the conflation window. */
+	send(unit, op, keep = false, now = null, route = void 0, relax = null) {
+		const i = op.i ?? this.next++;
+		const o = {
+			i,
+			...op
+		};
+		return new Promise((resolve) => {
+			let timer = null, me = null;
+			const wait = () => {
+				timer = setTimeout(() => {
+					if (this.waiting.get(i) !== me) return;
+					if (!keep) {
+						this.waiting.delete(i);
+						resolve({
+							i,
+							ok: false,
+							why: "timeout"
+						});
+						return;
+					}
+					if (me.sent && !me.queued && !me.later) {
+						this.stats.resent += 1;
+						this.queue(me.unit, me.op);
+					}
+					wait();
+				}, keep ? 5e3 : 1e4);
+			};
+			wait();
+			me = {
+				unit,
+				op: o,
+				resolve: (a) => {
+					clearTimeout(timer);
+					if (o.t) this.store?.answered(o, a);
+					resolve(a);
+				},
+				keep,
+				now,
+				route,
+				sent: false,
+				at: performance.now(),
+				durable: keep && !!o.t && this.durable && !relax,
+				relax,
+				early: relax === "e" ? resolve : null
+			};
+			this.waiting.set(i, me);
+			if (keep && o.t) this.store?.issued(o, route);
+			this.queue(unit, o);
+		});
+	}
+	queue(unit, op) {
+		const w = this.waiting.get(op.i);
+		if (w && w.op === op) {
+			w.queued = true;
+			w.gen = (w.gen ?? 0) + 1;
+		}
+		this.schedule();
+		const now = performance.now(), g = this.gather ??= {
+			n: 0,
+			sum: 0
+		};
+		g.n += 1;
+		g.sum += now;
+		if (!this.outbox.has(unit)) this.outbox.set(unit, []);
+		this.outbox.get(unit).push(op);
+	}
+	/** The send window now: `window` when given, else the AIMD's (0 .. budgetMs). */
+	sendWindow() {
+		return this.window ?? this.aimd.value();
+	}
+	schedule() {
+		if (this.flushing) return;
+		this.flushing = true;
+		const wait = this.sendWindow() - (performance.now() - this.lastFlush);
+		if (wait > 0) this.flushTimer = setTimeout(() => {
+			this.flushing = false;
+			this.flush();
+		}, wait);
+		else queueMicrotask(() => {
+			this.flushing = false;
+			this.flush();
+		});
+	}
+	/** (A3) After a send: the mean wait its ops were held for; the window rises a tenth of the budget while that is
+	*  at most half the budget and halves above it (an op issued right after an answer, while the window is open, waits
+	*  most of it). The window never passes the budget, so no op waits longer; a sparse client (ops further apart than the
+	*  budget) never waits at all. */
+	tune(now) {
+		const g = this.gather;
+		this.gather = null;
+		if (this.window === null && g?.n) this.aimd.observe(now - g.sum / g.n);
+	}
+	/** Tagged writes sent and not yet answered or durable: a unit remembers a client's last TAG_KEEP answers, so
+	*  at most TAG_KEEP may be in doubt at once (a resend of one older than that could run again). Counted per
+	*  acting user (`as`): the edge keeps each user's tags apart, so each has its own TAG_KEEP. */
+	doubts() {
+		const d = /* @__PURE__ */ new Map(), inc = (op) => d.set(op.as ?? "", (d.get(op.as ?? "") ?? 0) + 1);
+		for (const u of this.unconfirmed.values()) inc(u.op);
+		for (const w of this.waiting.values()) if (w.sent && w.op.t && !this.unconfirmed.has(w.op.i)) inc(w.op);
+		return d;
+	}
+	ambiguous() {
+		let n = 0;
+		for (const v of this.doubts().values()) n += v;
+		return n;
+	}
+	/** ACK: the lowest number of this client's own tags still in doubt (waiting for its answer, held, or answered
+	*  and not durable yet). Every number below it is settled and never sent again, so each tagged op carries it (`ta`)
+	*  and the unit drops that client's answers below it: a unit keeps the answers in flight, not the last TAG_KEEP. */
+	low() {
+		let low = this.tags + 1;
+		const see = (op) => {
+			if (!op?.t) return;
+			const t = String(op.t), k = t.lastIndexOf(":");
+			if (k < 0 || t.slice(0, k) !== this.client) return;
+			const n = Number(t.slice(k + 1));
+			if (n < low) low = n;
+		};
+		for (const w of this.waiting.values()) see(w.op);
+		for (const u of this.unconfirmed.values()) see(u.op);
+		for (const [, op] of this.held) see(op);
+		return low;
+	}
+	flush() {
+		if (!this.ws || this.ws.readyState !== 1) return;
+		if (!this.dir && !this.helloSeen) return;
+		const now = performance.now();
+		const doubt = this.doubts(), room = (ns) => (doubt.get(ns) ?? 0) < (this.tagKeep ?? 64), count = (ns) => doubt.set(ns, (doubt.get(ns) ?? 0) + 1);
+		const blocked = /* @__PURE__ */ new Set(), still = [];
+		const go = /* @__PURE__ */ new Map(), add = (unit, op) => {
+			if (!go.has(unit)) go.set(unit, []);
+			go.get(unit).push(op);
+		};
+		const seen = /* @__PURE__ */ new Set(), owed = (op) => !seen.has(op.i) && (op.k === "unsub" || this.waiting.get(op.i)?.op === op) && !!seen.add(op.i);
+		for (const [unit, op] of this.held) {
+			if (!owed(op)) continue;
+			const ns = op.as ?? "";
+			if (!blocked.has(ns) && room(ns)) {
+				add(unit, op);
+				count(ns);
+			} else {
+				blocked.add(ns);
+				still.push([unit, op]);
+			}
+		}
+		this.held = still;
+		for (const [unit, all] of this.outbox) for (const op of all) {
+			if (!owed(op)) continue;
+			const w = this.waiting.get(op.i), ns = op.as ?? "";
+			if (op.t && w && !w.sent) {
+				if (blocked.has(ns) || !room(ns)) {
+					blocked.add(ns);
+					this.held.push([unit, op]);
+					this.stats.held = (this.stats.held ?? 0) + 1;
+					continue;
+				}
+				count(ns);
+			}
+			add(unit, op);
+		}
+		this.outbox.clear();
+		for (const w of [...this.leaving.values()]) if (go.has(w.unit)) {
+			go.get(w.unit).push(this.unsubOp(w));
+			this.stats.unsubsRode += 1;
+		}
+		if (!this.leaving.size) {
+			clearTimeout(this.leaveTimer);
+			this.leaveTimer = null;
+		}
+		if (go.size) {
+			this.tune(now);
+			this.lastFlush = this.lastSent = now;
+		}
+		const low = go.size ? this.low() : 0;
+		const sends = [];
+		for (const [unit, all] of go) {
+			if (!this.far) {
+				sends.push([
+					unit,
+					all,
+					false
+				]);
+				continue;
+			}
+			const atEdge = (op) => op.k === "g" || op.k === "sub" || op.k === "unsub", here = all.filter(atEdge), there = all.filter((op) => !atEdge(op));
+			if (here.length) sends.push([
+				unit,
+				here,
+				true
+			]);
+			if (there.length) sends.push([
+				unit,
+				there,
+				false
+			]);
+		}
+		for (const [unit, all, edgeOnly] of sends) for (let s = 0; s < all.length; s += 1e3) {
+			const ops = all.slice(s, s + 1e3);
+			this.stats.messages += 1;
+			this.stats.ops += ops.length;
+			for (const op of ops) {
+				if (op.t && originOf(op.t) === this.client) op.ta = low;
+				const w = this.waiting.get(op.i);
+				if (!w) continue;
+				if (!w.sent && op.t) this.store?.sent(op);
+				w.sent = true;
+				w.queued = false;
+				w.sentAt ??= now;
+				if (w.early) {
+					w.early({
+						i: op.i,
+						ok: true,
+						sent: true
+					});
+					w.early = null;
+				}
+			}
+			this.sentMsgs.delete(ops[0].i);
+			this.sentMsgs.set(ops[0].i, {
+				unit,
+				ops
+			});
+			if (this.sentMsgs.size > 4096) this.sentMsgs.delete(this.sentMsgs.keys().next().value);
+			const text = `${unit}|${JSON.stringify(ops)}`;
+			this.stats.bytesOut = (this.stats.bytesOut ?? 0) + text.length;
+			const lane = edgeOnly ? null : this.laneFor(unit);
+			if (lane) {
+				this.stats.laneMsgs = (this.stats.laneMsgs ?? 0) + 1;
+				for (const op of ops) {
+					const w = this.waiting.get(op.i);
+					if (w) w.lane = lane;
+					if (op.k === "sub") {
+						const sub = this.byI.get(op.i);
+						if (sub) sub.lane = lane;
+					}
+				}
+			} else for (const op of ops) {
+				const w = this.waiting.get(op.i);
+				if (w) w.lane = null;
+			}
+			(lane?.ws ?? this.ws).send(text);
+		}
+	}
+	received(data, lane = null) {
+		if (data === "pong") return;
+		const body = JSON.parse(data);
+		if (body.hello) {
+			this.setDir(body.hello.dir);
+			this.esc = body.hello.esc ?? this.esc;
+			this.helloed();
+			if (body.hello.far) {
+				this.far = true;
+				this.lanes ??= /* @__PURE__ */ new Map();
+			}
+			this.dur = body.hello.dur ?? {};
+			this.helloSeen = true;
+			if (body.hello.tk > 64) this.tagKeep = body.hello.tk;
+			if (this.outbox.size) this.schedule();
+			return;
+		}
+		if (body.dir && !Array.isArray(body)) {
+			this.setDir(body.dir);
+			return;
+		}
+		if (body.move) {
+			if (lane) {
+				this.laneLost(lane, "move");
+				return;
+			}
+			this.stats.edgeMoves = (this.stats.edgeMoves ?? 0) + 1;
+			this.drop("move");
+			return;
+		}
+		if (!Array.isArray(body) && body.a) {
+			this.received(JSON.stringify(body.a), lane);
+			delete body.a;
+		}
+		if (!Array.isArray(body)) {
+			if (body.busy !== void 0) {
+				this.refusedMsg(body);
+				return;
+			}
+			if (body.resub !== void 0) {
+				for (const w of this.watches.values()) if (w.unit === body.resub) this.subscribe(w);
+				for (const w of [...this.leaving.values()]) if (w.unit === body.resub) {
+					this.leaving.delete(w.key);
+					this.gone(w);
+				}
+			}
+			if (body.edgeReset) {
+				this.stats.edgeResets = (this.stats.edgeResets ?? 0) + 1;
+				if (lane) this.laneLost(lane, "reset");
+				else this.resend();
+			}
+			if (body.unitLost !== void 0) {
+				for (const [i, u] of this.unconfirmed) if (u.unit === body.unitLost && !this.waiting.has(i)) {
+					this.stats.resent += 1;
+					this.waiting.set(i, {
+						unit: u.unit,
+						op: u.op,
+						resolve: () => {},
+						keep: true,
+						sent: false,
+						at: u.at
+					});
+					this.queue(u.unit, u.op);
+				}
+			}
+			if (body.push) for (const item of body.push) this.pushed(item);
+			if (body.dur) for (const i of body.dur) {
+				const u = this.unconfirmed.get(i);
+				if (u) {
+					this.unconfirmed.delete(i);
+					this.store?.durable(u.op);
+					this.durTimes.push(performance.now() - u.at);
+					if (this.durTimes.length > 1e5) this.durTimes.shift();
+					u.done?.();
+				}
+			}
+			return;
+		}
+		const link = [], busy = [], moved = [];
+		let linkMs = 0, busyMs = 0, movedMs = 0;
+		for (const a of body) {
+			const w = this.waiting.get(a.i);
+			if (!w) continue;
+			if (/^link/u.test(a.why ?? "") && (w.keep || READ_OPS.has(w.op.k)) && (w.retries = (w.retries ?? 0) + 1) <= (w.keep ? 40 : 10)) {
+				this.stats.resent += 1;
+				link.push(w);
+				linkMs = Math.max(linkMs, Math.min(2e3, 50 * w.retries));
+				continue;
+			}
+			if ((a.err ?? a.why) === "busy" && (w.busy = (w.busy ?? 0) + 1) <= 50) {
+				this.stats.busy = (this.stats.busy ?? 0) + 1;
+				busy.push(w);
+				busyMs = Math.max(busyMs, a.retry ?? 100);
+				continue;
+			}
+			if (a.why === "moved" && w.route !== void 0 && (w.moves = (w.moves ?? 0) + 1) <= 50) {
+				this.stats.moved += 1;
+				moved.push(w);
+				movedMs = Math.max(movedMs, w.moves > 2 ? 10 * w.moves : 0);
+				continue;
+			}
+			if (w.relax && w.sentAt !== void 0) this.conflateAimd.observe(performance.now() - w.sentAt);
+			this.waiting.delete(a.i);
+			for (const r of a.wrote ?? []) this.wrote(`${r.t}/${r.id}`, r.v);
+			const prev = this.unconfirmed.get(a.i), last = w.durable && a.pend ? () => w.resolve({
+				...a,
+				pend: void 0,
+				durable: true
+			}) : null;
+			if (a.pend) this.unconfirmed.set(a.i, {
+				unit: w.unit,
+				op: w.op,
+				at: w.at ?? prev?.at ?? performance.now(),
+				done: prev?.done ?? last,
+				lane: w.lane ?? null
+			});
+			else if (prev) {
+				this.unconfirmed.delete(a.i);
+				prev.done?.();
+			}
+			w.now?.(a);
+			if (!last) w.resolve(a);
+		}
+		if (link.length) this.retry(link, linkMs);
+		if (busy.length) this.retry(busy, busyMs + Math.random() * busyMs / 2);
+		if (moved.length) this.retry(moved, this.refreshDir().then(() => movedMs), (w) => {
+			w.unit = this.unitOf(w.route);
+		});
+	}
+	/** Ops answered "again later" go again together after `wait` ms (a number or a Promise of one), each only if
+	*  it still waits and nothing has queued it since (a reconnect's resend, the keep timer): never queued twice.
+	*  `then(w)` runs just before (a moved op takes its new unit). */
+	retry(ws, wait, then) {
+		const gens = ws.map((w) => {
+			w.later = (w.later ?? 0) + 1;
+			return w.gen;
+		});
+		Promise.resolve(wait).then((ms) => setTimeout(() => ws.forEach((w, k) => {
+			w.later -= 1;
+			if (this.waiting.get(w.op.i) !== w || w.gen !== gens[k] || w.queued) return;
+			then?.(w);
+			this.queue(w.unit, w.op);
+		}), ms));
+	}
+	/** A whole message refused `{busy: ms, m}`: its ops still unanswered go again after `ms` and up to half that
+	*  again (one timer for the message), same tags; an op refused 50 times is answered busy. */
+	refusedMsg({ busy: ms, m }) {
+		const sent = this.sentMsgs.get(m);
+		if (!sent) return;
+		this.sentMsgs.delete(m);
+		this.stats.busyMsgs = (this.stats.busyMsgs ?? 0) + 1;
+		const again = [], unsubs = [];
+		for (const op of sent.ops) {
+			if (op.k === "unsub") {
+				unsubs.push(op);
+				continue;
+			}
+			const w = this.waiting.get(op.i);
+			if (!w || w.op !== op) continue;
+			this.stats.busy = (this.stats.busy ?? 0) + 1;
+			if ((w.busy = (w.busy ?? 0) + 1) > 50) {
+				const a = {
+					i: op.i,
+					ok: false,
+					err: "busy",
+					why: "busy",
+					retry: ms
+				};
+				this.waiting.delete(op.i);
+				w.now?.(a);
+				w.resolve(a);
+				continue;
+			}
+			again.push(w);
+		}
+		const wait = ms + Math.random() * ms / 2;
+		if (again.length) this.retry(again, wait);
+		if (unsubs.length) {
+			const ws = this.ws;
+			setTimeout(() => {
+				if (this.ws !== ws) return;
+				for (const op of unsubs) this.queueRaw(sent.unit, op);
+				this.schedule();
+			}, wait);
+		}
+	}
+	/** An op into the outbox with no answer waited for (an unsub). */
+	queueRaw(unit, op) {
+		if (!this.outbox.has(unit)) this.outbox.set(unit, []);
+		this.outbox.get(unit).push(op);
+	}
+	wrote(key, v) {
+		if (v > (this.mine.get(key) ?? -1)) this.mine.set(key, v);
+	}
+	tag() {
+		return `${this.client}:${this.tags += 1}`;
+	}
+	/** A row's value (null when unborn): the optimistic value, else a fresh subscribed copy, else one read shared by
+	*  every caller asking at once. `as`: a server reads as that user (that user's rules). */
+	async get(tb, id, { as } = {}) {
+		const key = `${tb}/${id}`, rk = rowKey(tb, id, as ?? void 0);
+		if (as == null && this.overlay.has(key)) {
+			this.stats.localReads += 1;
+			return this.overlay.get(key);
+		}
+		let mineNow;
+		for (const u of this.unconfirmed.values()) if (u.op.k === "s" && u.op.as === (as ?? void 0) && `${u.op.tb}/${u.op.id}` === key) mineNow = u;
+		if (mineNow) {
+			this.stats.localReads += 1;
+			return mineNow.op.value;
+		}
+		const pending = this.conflating.get(`${as ?? ""}|${key}`);
+		if (pending) {
+			this.stats.localReads += 1;
+			return pending.value;
+		}
+		const held = this.rows.get(rk);
+		if (held && held.v >= (this.mine.get(key) ?? 0)) {
+			this.stats.localReads += 1;
+			if (this.auto.has(rk)) this.readAuto(tb, id, as ?? void 0, rk);
+			return held.value;
+		}
+		this.readAuto(tb, id, as ?? void 0, rk);
+		if (this.reads.has(rk)) {
+			this.stats.sharedReads += 1;
+			return this.reads.get(rk);
+		}
+		const ask = (fresh) => this.send(this.unitOf(id), {
+			k: "g",
+			tb,
+			id,
+			...asOf(as),
+			...fresh ? { fresh: 1 } : {}
+		}, true, null, id);
+		const read = ask(false).then((a) => a.edge && (a.v ?? 0) < (this.mine.get(key) ?? 0) ? ask(true) : a).then((a) => {
+			this.reads.delete(rk);
+			if (!a.ok && a.why !== "unborn") throw coded(a);
+			return a.ok ? a.value : null;
+		});
+		this.reads.set(rk, read);
+		return read;
+	}
+	/** Sets a row (expecting version `expect` when given: refused `changed` otherwise). A set of an "e" or "b"
+	*  table (the hello's `dur`) without `expect` is conflated (see the top of this file); an "s" table's never. */
+	async set(tb, id, value, { expect, tag, as } = {}) {
+		if (expect === void 0 && this.durOf(tb) !== "s") return this.conflate(tb, id, value, {
+			tag,
+			as
+		});
+		return this.setNow(tb, id, value, {
+			expect,
+			tag,
+			as
+		});
+	}
+	async setNow(tb, id, value, { expect, tag, as } = {}) {
+		const d = this.durOf(tb), relax = d === "s" ? null : expect === void 0 ? d : "b";
+		const a = await this.send(this.unitOf(id), {
+			k: "s",
+			tb,
+			id,
+			e: expect,
+			value,
+			t: tag ?? this.tag(),
+			...asOf(as),
+			...relax ? {} : this.urgent()
+		}, true, null, id, relax);
+		if (refused(a)) throw coded(a);
+		if (a.ok) this.wrote(`${tb}/${id}`, a.v);
+		return a;
+	}
+	/** Server shapes ask for an urgent frame and an immediate receipt (`w: 1`: their writes resolve when durable). */
+	urgent() {
+		return this.durable ? { w: 1 } : {};
+	}
+	/** A table's durability from the hello: "e" | "b" | "s" (absent, or before the hello: "s"). */
+	durOf(tb) {
+		const d = this.dur?.[tb];
+		return d === "e" || d === "b" ? d : "s";
+	}
+	/** The conflation window now, ms (AIMD on the round trips of "e"/"b" writes, 50..100). */
+	conflateWindow() {
+		return this.conflateAimd.value();
+	}
+	/** (A10) The first conflated set opens ONE window for every row (`conflateWindow()` ms); a later set of
+	*  a row waiting in it only replaces the value (and the tag, when it brings one); at its end every row goes with its
+	*  last value, together (one message per unit). Every caller gets its row's answer. A set tagged by another tab (or
+	*  untagged after a tab's, or the reverse) is never merged: the waiting one goes now, the new one waits (else the
+	*  older value, resent by its tab with its own tag after a handover, could land last). */
+	conflate(tb, id, value, { tag, as }) {
+		const key = `${as ?? ""}|${tb}/${id}`, from = tag === void 0 || tag === null ? null : originOf(tag);
+		const c = this.conflating.get(key);
+		if (c && c.from === from) {
+			c.value = value;
+			c.tag = tag ?? c.tag;
+			this.stats.conflated += 1;
+			return c.answer;
+		}
+		if (c) {
+			this.conflating.delete(key);
+			c.go();
+		}
+		const n = {
+			value,
+			tag,
+			from
+		};
+		n.answer = new Promise((r) => {
+			n.go = () => r(this.setNow(tb, id, n.value, {
+				tag: n.tag,
+				as
+			}));
+		});
+		this.conflating.set(key, n);
+		if (!this.conflateTimer) {
+			this.conflateTimer = setTimeout(() => this.conflateFlush(), this.conflateWindow());
+			this.conflateTimer.unref?.();
+		}
+		return n.answer;
+	}
+	/** The conflation window's end: every row waiting goes now, in one turn. */
+	conflateFlush() {
+		this.conflateTimer = null;
+		const all = [...this.conflating.values()];
+		this.conflating.clear();
+		for (const n of all) n.go();
+	}
+	/** Takes `n` from `row[f]` if at least `min` is left (escrow: hot stock). A table the hello lists in `esc` keeps the
+	*  amount in slices `id~0..slices-1`: this client always takes from its own slice (the unit borrows from the others).
+	*  Resolves `{ v, left }`; throws code `short` (`have` on the answer) when there is not enough. */
+	async take(tb, id, f, n, { min = 0, tag, as } = {}) {
+		await Promise.race([this.hello, new Promise((r) => setTimeout(r, 2e3))]);
+		const e = this.esc?.[tb], row = e ? `${id}~${fnv(this.client) % e.slices}` : id;
+		const a = await this.send(this.unitOf(row), {
+			k: "take",
+			tb,
+			id: row,
+			f,
+			n,
+			min,
+			t: tag ?? this.tag(),
+			...asOf(as),
+			...this.urgent()
+		}, true, null, row);
+		if (a.err || a.ok === false) throw coded(a);
+		for (const r of a.wrote ?? []) this.wrote(`${r.t}/${r.id}`, r.v);
+		return a;
+	}
+	/** Runs a server mutation in the unit of `route` (a row id it writes). `optimistic`: { "tb/id": value } shown at
+	*  once to `get` and to row watchers until the answer. */
+	async mutation(name, args, { route = "", optimistic, tag, as } = {}) {
+		name = fnName(name);
+		const keys = Object.keys(optimistic ?? {});
+		for (const key of keys) {
+			this.overlay.set(key, optimistic[key]);
+			this.notifyRow(key);
+		}
+		const guess = optimistic || as != null ? null : this.predictor?.begin(name, args, route);
+		const a = await this.send(this.unitOf(route), {
+			k: "m",
+			f: name,
+			a: args,
+			t: tag ?? this.tag(),
+			...asOf(as),
+			...this.urgent()
+		}, true, null, route);
+		guess?.end(a);
+		for (const key of keys) {
+			this.overlay.delete(key);
+			this.notifyRow(key);
+		}
+		if (refused(a)) throw coded(a);
+		return a;
+	}
+	/** An ACTION of a the database app (it may do I/O; not a transaction): called as a mutation is, by reference or
+	*  name, tagged (a resend after a reconnect is answered from its tag). Resolves its answer. */
+	async action(name, args, options = {}) {
+		return this.mutation(name, args, options);
+	}
+	/** A query function's value, once, on unit `unit` (default "0"). */
+	async query(name, args, { unit = "0", as } = {}) {
+		name = fnName(name);
+		const a = await this.send(String(unit), {
+			k: "q",
+			f: name,
+			a: args,
+			...asOf(as)
+		});
+		if (!a.ok) throw coded(a);
+		return a.value;
+	}
+	/** A range over an index, once: every unit's part (or `unit`'s), rows concatenated in unit order. */
+	async range(tb, index, o = {}, { unit, as } = {}) {
+		if (unit === void 0 && !this.dir) await Promise.race([this.hello, new Promise((r) => setTimeout(r, HELLO_WAIT_MS))]);
+		const units = unit !== void 0 ? [String(unit)] : this.unitNames();
+		const parts = await Promise.all(units.map((u) => this.send(u, {
+			k: "r",
+			tb,
+			index,
+			...o,
+			...asOf(as)
+		})));
+		const bad = parts.find((a) => !a.ok);
+		if (bad) throw coded(bad);
+		return parts.flatMap((a) => a.rows ?? []);
+	}
+	/** A read of a row not held here (or held because it was read often): counted; the `subscribeAfter`th within
+	*  `subscribeWindowMs` subscribes it, if the cache admits it. */
+	readAuto(tb, id, as, rk) {
+		if (!this.subscribeAfter) return;
+		const now = performance.now();
+		this.lfu.touch(rk);
+		const a = this.auto.get(rk);
+		if (a) {
+			this.keep.gap(now - a.last);
+			a.last = now;
+			a.reads.add(1, now);
+			this.auto.delete(rk);
+			this.auto.set(rk, a);
+			this.sweepAuto(now);
+			return;
+		}
+		this.sweepAuto(now);
+		if (this.never.has(rk) || this.watches.has(`${this.unitOf(id)}|${JSON.stringify({
+			k: "g",
+			tb,
+			id
+		})}${as === void 0 ? "" : `|${as}`}`)) return;
+		let h = this.heat.get(rk);
+		if (!h || now - h.at > this.subscribeWindowMs) {
+			this.heat.delete(rk);
+			h = {
+				at: now,
+				n: 0
+			};
+			this.heat.set(rk, h);
+			if (this.heat.size > 4 * this.lfu.size + 1e3) this.heat.delete(this.heat.keys().next().value);
+		}
+		if ((h.n += 1) < this.subscribeAfter) return;
+		this.heat.delete(rk);
+		for (const k of this.lfu.add(rk)) if (k !== rk) this.dropAuto(k);
+		if (!this.lfu.has(rk)) return;
+		const entry = {
+			tb,
+			id,
+			as,
+			last: now,
+			reads: new Rate(1e4).add(h.n, now),
+			pushes: new Rate(1e4),
+			stop: null
+		};
+		this.auto.set(rk, entry);
+		this.stats.autoSubs += 1;
+		entry.stop = this.watchRow(tb, id, (view, w, item) => {
+			if (view === void 0 && w?.error) {
+				if (/denied/u.test(w.error.err ?? w.error.why ?? "")) {
+					if (this.never.size > 1e4) this.never.clear();
+					this.never.add(rk);
+				}
+				this.dropAuto(rk);
+				return;
+			}
+			if (item) {
+				entry.pushes.add(1);
+				this.sweepAuto(performance.now(), rk);
+			}
+		}, as === void 0 ? void 0 : { as });
+	}
+	/** Whether a subscribed row has gone quiet: idle past the p99 of the read gaps seen (when they form a pattern) or
+	*  past the break-even of holding it against reading it again. Pushes are not billed messages: holding costs
+	*  only their server CPU (`pushCpuMs`, at least one push a minute); a read costs a message the client sends plus its
+	*  relay CPU (`relayCpuMs`), at its read rate. */
+	quiet(a, now) {
+		const be = breakEvenMs({
+			holdUsdPerSec: Math.max(a.pushes.perSec(now), 1 / 60) * PUSH_USD,
+			eachUsd: READ_USD,
+			ratePerSec: a.reads.perSec(now)
+		});
+		const keepMs = this.keep.shape().patterned ? Math.min(this.keep.keepMs(), be) : be;
+		return now - a.last > keepMs;
+	}
+	/** Drops quiet subscriptions: `rk` (a row just pushed), and the least recently read few. No timer: run as reads and
+	*  pushes come. */
+	sweepAuto(now, rk) {
+		if (rk !== void 0) {
+			const a = this.auto.get(rk);
+			if (a && this.quiet(a, now)) this.dropAuto(rk);
+		}
+		let n = 0;
+		for (const [k, a] of this.auto) {
+			if (n++ >= 4 || !this.quiet(a, now)) break;
+			this.dropAuto(k);
+		}
+	}
+	dropAuto(rk) {
+		const a = this.auto.get(rk);
+		this.lfu.delete(rk);
+		if (!a) return;
+		this.auto.delete(rk);
+		this.stats.autoDrops += 1;
+		a.stop?.();
+	}
+	/** Stores a file (R2) and its `_files` row (owner: this user); resolves its id. */
+	async upload(blob, name) {
+		const put = () => fetch(`${this.base}/files?${this.auth()}&name=${encodeURIComponent(name)}`, {
+			method: "PUT",
+			body: blob
+		});
+		let r = await put();
+		if (r.status === 401 && this.refresh) {
+			await this.renew();
+			r = await put();
+		}
+		if (!r.ok) throw coded({ err: r.status === 401 || r.status === 403 ? "denied" : `http ${r.status}` });
+		return (await r.json()).id;
+	}
+	/** A URL that streams a stored file (for <img src>, links); it carries the current token. */
+	fileUrl(id) {
+		return `${this.base}/files/${encodeURIComponent(id)}?${this.auth()}`;
+	}
+	/** Watches a query on one unit; identical watches share one subscription. Returns the unsubscribe function.
+	*  `as`: a server watches as that user (its own subscription: that user's rules). */
+	watch(q, unit, listener, { as } = {}) {
+		as = as ?? void 0;
+		const key = `${unit}|${JSON.stringify(q)}${as === void 0 ? "" : `|${as}`}`;
+		let w = this.watches.get(key);
+		const back = !w && this.leaving.get(key);
+		if (back) {
+			w = back;
+			this.leaving.delete(key);
+			this.watches.set(key, w);
+			this.stats.rewatched += 1;
+		}
+		if (w) {
+			if (!back) this.stats.sharedWatches += 1;
+			w.listeners.add(listener);
+			if (w.state) listener(this.view(w), w);
+		} else {
+			w = {
+				key,
+				q,
+				unit,
+				as,
+				state: null,
+				seq: -1,
+				listeners: /* @__PURE__ */ new Set([listener])
+			};
+			this.watches.set(key, w);
+			this.subscribe(w);
+		}
+		if (!w.state) {
+			const old = this.store?.cached(w);
+			if (old !== void 0) listener(old, { stale: true });
+		}
+		return () => {
+			w.listeners.delete(listener);
+			if (w.listeners.size || this.watches.get(key) !== w) return;
+			this.watches.delete(key);
+			this.leave(w);
+		};
+	}
+	/** The last listener left: the subscription stays (pushes keep its copy current, reads use it) until its unsub
+	*  rides a message to its unit (flush), or LEAVE_MS passes and it goes alone. A refused one has nothing to unsub; one
+	*  whose sub was never sent is simply not sent. */
+	leave(w) {
+		if (!w.state && w.error) {
+			this.gone(w);
+			return;
+		}
+		const sub = this.waiting.get(w.i);
+		if (sub && !sub.sent) {
+			this.waiting.delete(w.i);
+			sub.resolve({
+				i: w.i,
+				ok: false,
+				why: "left"
+			});
+			this.gone(w);
+			return;
+		}
+		this.leaving.set(w.key, w);
+		if (!this.leaveTimer) {
+			this.leaveTimer = setTimeout(() => this.leaveAll(), LEAVE_MS);
+			this.leaveTimer.unref?.();
+		}
+	}
+	/** The unsubs still waiting go now (one message per unit). */
+	leaveAll() {
+		this.leaveTimer = null;
+		for (const w of [...this.leaving.values()]) this.queueRaw(w.unit, this.unsubOp(w));
+		this.schedule();
+	}
+	/** A left watch's unsub op; it is gone here from now on. */
+	unsubOp(w) {
+		this.leaving.delete(w.key);
+		this.gone(w);
+		this.stats.unsubs += 1;
+		return {
+			i: this.next++,
+			k: "unsub",
+			s: w.i
+		};
+	}
+	/** A watch no longer subscribed: its pushes are not heard, its row copy not used. */
+	gone(w) {
+		if (this.byI.get(w.i) === w) this.byI.delete(w.i);
+		if (w.q.k === "g") this.rows.delete(rowKey(w.q.tb ?? "rows", w.q.id, w.as));
+	}
+	/** (Re)subscribes a watch under a new op i: its next answer resets its state. */
+	subscribe(w) {
+		if (w.i !== void 0) this.byI.delete(w.i);
+		w.i = this.next++;
+		w.state = null;
+		this.byI.set(w.i, w);
+		if (w.q.k === "g") w.unit = this.unitOf(w.q.id);
+		w.ready = this.send(w.unit, {
+			k: "sub",
+			q: w.q,
+			i: w.i,
+			...asOf(w.as)
+		}, false, (a) => this.started(w, a), w.q.k === "g" ? w.q.id : void 0);
+	}
+	started(w, a) {
+		if (!a.ok) {
+			w.error = a;
+			for (const l of w.listeners) l(void 0, w);
+			return a;
+		}
+		w.seq = a.seq ?? 0;
+		w.state = w.q.k === "r" ? {
+			ids: a.rows.map((r) => r._id),
+			rows: new Map(a.rows.map((r) => [r._id, r]))
+		} : w.q.k === "f" ? { value: a.value } : a.gone ? {
+			v: 0,
+			gone: true
+		} : {
+			v: a.v,
+			value: a.value
+		};
+		this.settled(w);
+		return a;
+	}
+	pushed(item) {
+		const w = this.byI.get(item.s);
+		if (!w || !w.state) return;
+		if (item.lost) {
+			if (this.leaving.get(w.key) === w) {
+				this.leaving.delete(w.key);
+				this.gone(w);
+			} else this.subscribe(w);
+			return;
+		}
+		this.stats.pushes += 1;
+		if (!(item.seq > w.seq)) this.stats.outOfOrder += 1;
+		w.seq = item.seq;
+		if (w.q.k === "r") {
+			const s = w.state, ids = item.ids ?? s.ids, keep = new Set(ids);
+			for (const r of item.rows ?? []) s.rows.set(r._id, r);
+			s.ids = ids;
+			for (const id of [...s.rows.keys()]) if (!keep.has(id)) s.rows.delete(id);
+		} else if (w.q.k === "f") w.state = { value: item.value };
+		else w.state = item.gone ? {
+			v: 0,
+			gone: true
+		} : {
+			v: item.v,
+			value: item.value
+		};
+		this.settled(w, item);
+	}
+	settled(w, item) {
+		if (w.q.k === "g") {
+			const key = rowKey(w.q.tb ?? "rows", w.q.id, w.as);
+			this.rows.set(key, w.state.gone ? {
+				v: 0,
+				value: null
+			} : {
+				v: w.state.v,
+				value: w.state.value
+			});
+		}
+		for (const l of w.listeners) l(this.view(w), w, item);
+		this.store?.saw(w);
+		this.predictor?.saw(w);
+	}
+	view(w) {
+		if (w.q.k === "r") return w.state.ids.map((id) => w.state.rows.get(id));
+		if (w.q.k === "f") return w.state.value;
+		const key = `${w.q.tb ?? "rows"}/${w.q.id}`;
+		return w.as === void 0 && this.overlay.has(key) ? {
+			v: w.state.v,
+			value: this.overlay.get(key),
+			optimistic: true
+		} : w.state;
+	}
+	notifyRow(key) {
+		const cut = key.indexOf("/");
+		const w = this.watches.get(`${this.unitOf(key.slice(cut + 1))}|${JSON.stringify({
+			k: "g",
+			tb: key.slice(0, cut),
+			id: key.slice(cut + 1)
+		})}`);
+		if (w?.state) for (const l of w.listeners) l(this.view(w), w);
+	}
+	watchRow(tb, id, listener, { as } = {}) {
+		return this.watch({
+			k: "g",
+			tb,
+			id
+		}, this.unitOf(id), listener, { as });
+	}
+	/** A query on every unit of the map, kept in step with it (a split adds a unit): `onParts(Map name -> value)` once
+	*  every unit has answered. Returns the unsubscribe function. */
+	everyUnit(q, onParts, { as } = {}) {
+		const parts = /* @__PURE__ */ new Map(), stops = /* @__PURE__ */ new Map(), stale = /* @__PURE__ */ new Set();
+		const emit = () => {
+			const names = this.unitNames();
+			if (names.every((n) => parts.get(n) !== void 0)) onParts(new Map(names.map((n) => [n, parts.get(n)])), { stale: names.some((n) => stale.has(n)) });
+		};
+		const sync = () => {
+			const names = new Set(this.unitNames());
+			for (const name of names) if (!stops.has(name)) stops.set(name, this.watch(q, name, (v, w) => {
+				parts.set(name, v);
+				if (w?.stale) stale.add(name);
+				else stale.delete(name);
+				emit();
+			}, { as }));
+			for (const [name, stop] of [...stops]) if (!names.has(name)) {
+				stop();
+				stops.delete(name);
+				parts.delete(name);
+			}
+			emit();
+		};
+		this.dirListeners.add(sync);
+		sync();
+		return () => {
+			this.dirListeners.delete(sync);
+			for (const stop of stops.values()) stop();
+		};
+	}
+	/** A range over an index on every unit, merged: by `by` (the index's field) then id. */
+	watchRange(tb, index, o, listener, { by, as } = {}) {
+		return this.everyUnit({
+			k: "r",
+			tb,
+			index,
+			...o
+		}, (parts, meta) => {
+			const rows = /* @__PURE__ */ new Map();
+			for (const part of parts.values()) for (const r of part) rows.set(r._id, r);
+			listener([...rows.values()].sort((x, y) => by && x[by] !== y[by] ? x[by] < y[by] ? -1 : 1 : x._id < y._id ? -1 : x._id > y._id ? 1 : 0), meta);
+		}, { as });
+	}
+	/** A query function on one unit (by name). */
+	watchQuery(name, args, { unit = "0", as } = {}, listener) {
+		return this.watch({
+			k: "f",
+			f: fnName(name),
+			a: args
+		}, String(unit), listener, { as });
+	}
+	/** A query function on every unit: `listener(Map unit -> value)`. */
+	watchQueryAll(name, args, listener, { as } = {}) {
+		return this.everyUnit({
+			k: "f",
+			f: name,
+			a: args
+		}, listener, { as });
+	}
+	/** Closes the socket. A server shape's socket is the process's: it closes when every `connect` closed it. */
+	close() {
+		if (this.sharedKey && (this.refs -= 1) > 0) return;
+		if (this.sharedKey && SHARED.get(this.sharedKey)) SHARED.delete(this.sharedKey);
+		this.closed = true;
+		clearInterval(this.dog);
+		clearTimeout(this.renewer);
+		clearTimeout(this.flushTimer);
+		clearTimeout(this.leaveTimer);
+		try {
+			this.ws?.close(1e3);
+		} catch {}
+		for (const lane of this.lanes?.values() ?? []) try {
+			lane.ws.close(1e3);
+		} catch {}
+	}
+	/** Unit `unit`'s lane when it is open; else null (its ops take the socket), and one is opened when the map names a
+	*  row there. */
+	laneFor(unit) {
+		if (!this.lanes || !this.dir || unit === "*" || this.closed) return null;
+		let lane = this.lanes.get(unit);
+		if (!lane) {
+			const hk = `${this.dir.v}|${unit}`;
+			if (!this.homes?.has(hk)) {
+				if ((this.homes ??= /* @__PURE__ */ new Map()).size > 256) this.homes.clear();
+				this.homes.set(hk, rowOn(this.dir, unit));
+			}
+			const home = this.homes.get(hk);
+			if (!home) return null;
+			const ws = new WebSocket(`${this.base.replace(/^http/u, "ws")}/ws?token=${encodeURIComponent(this.token)}&home=${encodeURIComponent(home)}`);
+			lane = {
+				unit,
+				ws,
+				open: false,
+				at: performance.now(),
+				heard: performance.now()
+			};
+			this.lanes.set(unit, lane);
+			this.stats.lanesOpened = (this.stats.lanesOpened ?? 0) + 1;
+			ws.addEventListener("open", () => {
+				if (this.lanes.get(unit) === lane) {
+					lane.open = true;
+					lane.heard = performance.now();
+				}
+			}, { once: true });
+			ws.addEventListener("message", (event) => {
+				if (this.lanes.get(unit) !== lane) return;
+				lane.heard = performance.now();
+				this.received(event.data, lane);
+				if (this.held.length) this.schedule();
+			});
+			ws.addEventListener("close", () => this.laneLost(lane, "close"));
+		}
+		return lane.open && lane.ws.readyState === 1 ? lane : null;
+	}
+	/** A lane gone (closed, `{move}`, silent, never opened): what it carries goes again on the next send (the unit's next
+	*  lane, or the socket), same tags, as a reconnect sends it; its subscriptions start again. */
+	laneLost(lane, why) {
+		if (this.lanes?.get(lane.unit) !== lane) return;
+		this.lanes.delete(lane.unit);
+		this.stats.lanesLost = (this.stats.lanesLost ?? 0) + 1;
+		try {
+			lane.ws.close(4e3, why);
+		} catch {}
+		if (this.closed) return;
+		const again = /* @__PURE__ */ new Set();
+		for (const w of [...this.waiting.values()]) {
+			if (w.lane !== lane) continue;
+			w.lane = null;
+			if (w.op.k === "sub") continue;
+			if (w.sent && !w.keep && !READ_OPS.has(w.op.k)) {
+				this.waiting.delete(w.op.i);
+				w.resolve({
+					i: w.op.i,
+					ok: false,
+					why: "closed"
+				});
+				continue;
+			}
+			this.stats.resent += 1;
+			w.sentAt = void 0;
+			again.add(w.op.i);
+			this.queue(w.unit, w.op);
+		}
+		for (const [i, u] of this.unconfirmed) if (u.lane === lane && !again.has(i) && !this.waiting.has(i)) {
+			u.lane = null;
+			this.stats.resent += 1;
+			this.waiting.set(i, {
+				unit: u.unit,
+				op: u.op,
+				resolve: () => {},
+				keep: true,
+				sent: false,
+				at: u.at
+			});
+			this.queue(u.unit, u.op);
+		}
+		for (const w of this.watches.values()) if (w.lane === lane) {
+			w.lane = null;
+			this.subscribe(w);
+		}
+	}
+	/** The watchdog's look at the lanes: one not open in 2 s, or silent while its ops wait (nothing heard `silent` ms, the
+	*  oldest op waiting 3x that), is lost. */
+	laneDog(now) {
+		for (const lane of [...this.lanes.values()]) {
+			if (!lane.open) {
+				if (now - lane.at > 2e3) this.laneLost(lane, "stuck");
+				continue;
+			}
+			let oldest = Infinity;
+			for (const w of this.waiting.values()) if (w.lane === lane && w.sentAt < oldest) oldest = w.sentAt;
+			if (now - oldest > 3 * this.silent && now - lane.heard > this.silent) this.laneLost(lane, "silent");
+		}
+	}
+};
+//#endregion
+export { TAG_TTL as n, Connection as t };