@midsummer-ai/sdk 0.1.0-next.1305 → 0.1.0-next.1723

package/{connection-CxD_Nry5.mjs → connection-BHjDaLYA.mjs}

@@ -164,12 +164,15 @@ var Aimd = class {
 		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));
-}
+//#endregion
+//#region src/database/client/connection.mjs
+/** How long a socket's open may take (its upgrade answered), ms; a reconnect's try still unopened at each of HEDGE_AT
+*  (ms from its start) gets another socket beside it, at most three at once. */
+const OPEN_WAIT = 1e4;
+const HEDGE_AT = [100, 200];
+/** A reconnect's waits between tries after the first (which is at once): RETRY_FIRST ms, doubling to RETRY_MAX. */
+const RETRY_FIRST = 50;
+const RETRY_MAX = 1e3;
 const TAG_TTL = 864e5;
 const groupOf = (id) => {
 	const t = String(id ?? ""), k = t.indexOf("/");
@@ -403,8 +406,8 @@ var Connection = class Connection {
 			...options,
 			shape
 		};
-		if (o.store === void 0 && typeof indexedDB !== "undefined" && typeof document !== "undefined") o.store = (await import("./store-DDuOr-_F.mjs")).idbStore(new URL(url).host);
-		if (o.tabs !== false && typeof document !== "undefined") return (await import("./tabs-4FLTfg1c.mjs")).ConnectionTabs.connect(url, o);
+		if (o.store === void 0 && typeof indexedDB !== "undefined" && typeof document !== "undefined") o.store = (await import("./store-BA8K-bAR.mjs")).idbStore(new URL(url).host);
+		if (o.tabs !== false && typeof document !== "undefined") return (await import("./tabs-DEeMee7M.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). */
@@ -412,6 +415,10 @@ var Connection = class Connection {
 		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);
+		if (options.shape === "server" && options.http !== false) {
+			g.http = true;
+			return g;
+		}
 		await g.open();
 		if (!g.dir) await Promise.race([g.hello, new Promise((r) => setTimeout(r, HELLO_WAIT_MS))]);
 		return g;
@@ -589,7 +596,7 @@ var Connection = class Connection {
 				try {
 					ws?.close(1e3);
 				} catch {}
-			}, 1e4);
+			}, OPEN_WAIT);
 			const opened = (ws) => {
 				clearTimeout(timer);
 				if (this.closed) {
@@ -599,6 +606,13 @@ var Connection = class Connection {
 					ready();
 					return;
 				}
+				if (this.ws && this.ws !== ws && this.ws.readyState === 1) {
+					try {
+						ws.close(1e3);
+					} catch {}
+					ready();
+					return;
+				}
 				this.ws = ws;
 				this.heard = this.answeredAt = this.openedAt = performance.now();
 				this.probe = 0;
@@ -648,22 +662,39 @@ var Connection = class Connection {
 			}
 		});
 	}
-	/** 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) {
+	/** Opens a socket again until one opens (one loop at a time): the first try at once, then after 50 ms doubling to
+	*  1 s, each wait jittered (clients a dead server dropped together do not come back together). A try still unopened
+	*  at 100 ms gets a second socket beside it and at 200 ms a third, and the first to open serves (the others are
+	*  closed): a socket the network sent to a replica that is gone costs at most 100 ms, while a slow open (a wake, a
+	*  long replay, a takeover waiting for a dead replica's lease) is never given up. */
+	async reconnect(delay = 0) {
 		if (this.reopening || this.closed) return;
 		this.reopening = true;
 		this.stats.reconnects += 1;
+		const opens = () => this.open().then(() => true, () => false);
+		const firstOf = (tries) => new Promise((done) => {
+			let n = 0;
+			for (const p of tries) p.then((ok) => {
+				if (ok) done(true);
+				else if (++n === tries.length) done(false);
+			});
+		});
 		try {
-			for (;;) {
-				await new Promise((r) => setTimeout(r, delay));
+			for (let step = RETRY_FIRST;;) {
+				if (delay > 0) 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);
+				const tries = [opens()];
+				let opened = null;
+				for (let k = 0, at = 0; k <= HEDGE_AT.length; k += 1) {
+					const wait = k < HEDGE_AT.length ? new Promise((r) => setTimeout(() => r(null), HEDGE_AT[k] - at)) : new Promise(() => {});
+					opened = await Promise.race([firstOf(tries), wait]);
+					if (opened !== null) break;
+					at = HEDGE_AT[k];
+					tries.push(opens());
 				}
+				if (opened) return;
+				delay = step * (.5 + Math.random() / 2);
+				step = Math.min(RETRY_MAX, step * 2);
 			}
 		} finally {
 			this.reopening = false;
@@ -779,6 +810,7 @@ var Connection = class Connection {
 	*  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) {
+		if (this.http && !this.ws && !this.reopening && !this.closed) this.reconnect(0);
 		const i = op.i ?? this.next++;
 		const o = {
 			i,
@@ -1379,12 +1411,15 @@ var Connection = class Connection {
 			this.notifyRow(key);
 		}
 		const guess = optimistic || as != null ? null : this.predictor?.begin(name, args, route);
-		const a = await this.send(this.unitOf(route), {
+		const op = {
 			k: "m",
 			f: name,
 			a: args,
 			t: tag ?? this.tag(),
-			...asOf(as),
+			...asOf(as)
+		};
+		const a = this.http && this.ws?.readyState !== 1 ? await this.overHttp(op) : await this.send(this.unitOf(route), {
+			...op,
 			...this.urgent()
 		}, true, null, route);
 		guess?.end(a);
@@ -1395,6 +1430,68 @@ var Connection = class Connection {
 		if (refused(a)) throw coded(a);
 		return a;
 	}
+	/** One query or mutation over HTTP (`POST <db>/call`, the token in its header), with no socket: its answer as a
+	*  socket's. A mutation's tag rides with it, so one sent again (after a failure the network gave no answer to)
+	*  applies once; a query, or a tagged mutation, is sent again on a 5xx or no answer, twice at most; a 401 renews the
+	*  token once. */
+	async overHttp(op) {
+		const body = JSON.stringify([{
+			i: 1,
+			...op
+		}]), again = op.k === "q" || !!op.t;
+		for (let tries = 0;; tries += 1) {
+			let r;
+			try {
+				r = await fetchAt(`${this.base}/call`, {
+					method: "POST",
+					headers: {
+						authorization: `Bearer ${this.token}`,
+						"content-type": "application/json"
+					},
+					body
+				});
+			} catch (e) {
+				if (again && tries < 2) continue;
+				return {
+					i: 1,
+					ok: false,
+					why: "unavailable",
+					error: String(e?.message ?? e)
+				};
+			}
+			if (r.status === 401 && this.refresh && tries === 0) {
+				await this.renew(false);
+				continue;
+			}
+			const text = await r.text();
+			if (!r.ok) {
+				if (r.status >= 500 && again && tries < 2) continue;
+				let j = {};
+				try {
+					j = JSON.parse(text);
+				} catch {}
+				return {
+					i: 1,
+					ok: false,
+					why: r.status === 401 ? "denied" : j.error ?? "refused",
+					error: j.why ?? text.slice(0, 200)
+				};
+			}
+			for (const line of text.split("\n")) try {
+				const v = JSON.parse(line);
+				if (Array.isArray(v)) {
+					const a = v.find((x) => x?.i === 1);
+					if (a) return a;
+				}
+			} catch {}
+			return {
+				i: 1,
+				ok: false,
+				why: "unavailable",
+				error: "no answer in the call's reply"
+			};
+		}
+	}
 	/** 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 = {}) {
@@ -1403,12 +1500,13 @@ var Connection = class Connection {
 	/** 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), {
+		const op = {
 			k: "q",
 			f: name,
 			a: args,
 			...asOf(as)
-		});
+		};
+		const a = this.http && this.ws?.readyState !== 1 ? await this.overHttp(op) : await this.send(String(unit), op);
 		if (!a.ok) throw coded(a);
 		return a.value;
 	}

package/database/client.mjs

@@ -1,5 +1,5 @@
 import { DatabaseError } from "./errors.mjs";
-import { t as Connection } from "../connection-CxD_Nry5.mjs";
+import { t as Connection } from "../connection-BHjDaLYA.mjs";
 //#region src/database/client.ts
 /**
 * `@midsummer-ai/sdk/database`: a Project's Database, from its app or its server.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@midsummer-ai/sdk",
-  "version": "0.1.0-next.1305",
+  "version": "0.1.0-next.1723",
   "license": "Apache-2.0",
   "type": "module",
   "description": "Midsummer's handles for an app's code: its Database, Storage, Queues, Vector DB, AI, Email and Agents, with stand-ins for tests.",

package/{store-DDuOr-_F.mjs → store-BA8K-bAR.mjs}

@@ -1,4 +1,4 @@
-import "./connection-CxD_Nry5.mjs";
+import "./connection-BHjDaLYA.mjs";
 //#region src/database/client/store.mjs
 const STORES = [
 	"ops",

package/{tabs-4FLTfg1c.mjs → tabs-DEeMee7M.mjs}

@@ -1,4 +1,4 @@
-import { t as Connection } from "./connection-CxD_Nry5.mjs";
+import { t as Connection } from "./connection-BHjDaLYA.mjs";
 //#region src/database/client/tabs.mjs
 /** Argument index of the options that take a `tag` (a tab tags its own writes: the same tag after a handover). */
 const TAGGED = {