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

package/tabs-DEeMee7M.mjs

@@ -0,0 +1,457 @@
+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 = {
+	set: 3,
+	take: 4,
+	mutation: 2
+};
+const CALLS = /* @__PURE__ */ new Set([
+	"get",
+	"set",
+	"take",
+	"mutation",
+	"query",
+	"range",
+	"upload",
+	"refreshDir",
+	"renew"
+]);
+/** The JSON options that open the shared Connection. */
+const OPEN = [
+	"token",
+	"units",
+	"edges",
+	"home",
+	"q",
+	"silent",
+	"window",
+	"budgetMs",
+	"tables",
+	"cacheRows",
+	"subscribeAfter",
+	"subscribeWindowMs"
+];
+const rid = () => Math.random().toString(36).slice(2, 10);
+const locks = () => typeof navigator !== "undefined" ? navigator.locks : void 0;
+/** Holds Web Lock `name` until the returned release is called; resolves once granted. */
+const hold = (name) => new Promise((granted) => {
+	locks().request(name, () => new Promise((release) => granted(release)));
+});
+const errorOf = (e) => ({
+	message: String(e?.message ?? e),
+	code: e?.code,
+	answer: e?.answer
+});
+const rebuild = (e) => Object.assign(new Error(e.message), e.code !== void 0 ? { code: e.code } : {}, e.answer !== void 0 ? { answer: e.answer } : {});
+/** The side that owns the one Connection: answers tabs' calls, holds their watches, tells them the Connection's state. */
+var TabsHost = class {
+	/** `local`: Connection options that cannot cross a port (store, functions, refresh). */
+	constructor(local = {}) {
+		this.local = local;
+		this.ready = null;
+		this.conn = null;
+		this.tabs = /* @__PURE__ */ new Map();
+		this.asks = /* @__PURE__ */ new Map();
+	}
+	/** One message from tab `tab`; `post` answers that tab. */
+	async handle(tab, msg, post) {
+		if (msg.hello) return this.hello(tab, msg.hello, post);
+		const t = this.tabs.get(tab);
+		if (!t) return;
+		if (msg.bye) {
+			this.drop(tab);
+			return;
+		}
+		if (msg.refreshed !== void 0) {
+			const ask = this.asks.get(msg.refreshed);
+			this.asks.delete(msg.refreshed);
+			if (ask) msg.error ? ask.fail(rebuild(msg.error)) : ask.ok(msg.token);
+			return;
+		}
+		if (msg.unsub !== void 0) {
+			t.subs.get(msg.unsub)?.();
+			t.subs.delete(msg.unsub);
+			return;
+		}
+		let g;
+		try {
+			g = await this.open();
+		} catch (e) {
+			if (msg.id !== void 0) t.post({
+				id: msg.id,
+				error: errorOf(e)
+			});
+			return;
+		}
+		if (!this.tabs.has(tab)) return;
+		if (msg.sub !== void 0) {
+			if (t.subs.has(msg.id)) return;
+			const args = [...msg.args];
+			args[msg.at] = (view, meta) => t.post({
+				s: msg.id,
+				view,
+				meta: meta && typeof meta === "object" ? { stale: !!meta.stale } : void 0
+			});
+			t.subs.set(msg.id, g[msg.sub](...args));
+			return;
+		}
+		if (CALLS.has(msg.call)) try {
+			t.post({
+				id: msg.id,
+				value: await g[msg.call](...msg.args)
+			});
+		} catch (e) {
+			t.post({
+				id: msg.id,
+				error: errorOf(e)
+			});
+		}
+	}
+	hello(tab, { url, opts, refresh }, post) {
+		const known = this.tabs.get(tab);
+		if (known) Object.assign(known, {
+			post,
+			refresh
+		});
+		else {
+			this.tabs.set(tab, {
+				post,
+				subs: /* @__PURE__ */ new Map(),
+				refresh
+			});
+			if (locks() && !this.self?.has(tab)) hold(`db-tab:${tab}`).then((release) => {
+				release();
+				this.drop(tab);
+			});
+		}
+		this.first ??= {
+			url,
+			opts
+		};
+		this.open().then(() => post({ state: this.state() }), (e) => post({
+			state: null,
+			error: errorOf(e)
+		}));
+	}
+	/** The Connection, opened by the first tab's options (again after a failed open). */
+	open() {
+		if (!this.ready) {
+			const { url, opts } = this.first;
+			const refresh = this.local.refresh ?? (opts.refresh ? () => this.askRefresh() : null);
+			this.ready = Connection.open(url, {
+				...opts,
+				...this.local,
+				refresh,
+				shape: "browser"
+			}).then((g) => {
+				this.conn = g;
+				const tell = () => {
+					const s = { state: this.state() };
+					for (const t of this.tabs.values()) t.post(s);
+				};
+				g.dirListeners.add(tell);
+				this.ticker = setInterval(tell, 1e3);
+				this.ticker.unref?.();
+				return g;
+			}, (e) => {
+				this.ready = null;
+				throw e;
+			});
+		}
+		return this.ready;
+	}
+	state() {
+		const g = this.conn;
+		return g ? {
+			dir: g.dir,
+			esc: g.esc,
+			token: g.token,
+			stats: { ...g.stats }
+		} : null;
+	}
+	/** A new token from a tab that has `refresh`. */
+	askRefresh() {
+		const t = [...this.tabs.values()].reverse().find((x) => x.refresh);
+		if (!t) return Promise.reject(/* @__PURE__ */ new Error("no tab can refresh the token"));
+		const id = rid();
+		return new Promise((ok, fail) => {
+			this.asks.set(id, {
+				ok,
+				fail
+			});
+			t.post({ refresh: id });
+		});
+	}
+	/** A tab gone: its watches stop (a subscription other tabs share stays). */
+	drop(tab) {
+		const t = this.tabs.get(tab);
+		if (!t) return;
+		this.tabs.delete(tab);
+		for (const stop of t.subs.values()) stop();
+	}
+	close() {
+		clearInterval(this.ticker);
+		this.conn?.close();
+		return this.conn?.store?.close?.();
+	}
+};
+var ConnectionTabs = class ConnectionTabs {
+	/** A Connection shared by every tab of this browser (see the top of this file); a plain Connection where tabs cannot share. */
+	static async connect(url, options) {
+		const shared = options.worker && typeof SharedWorker === "function";
+		if (!shared && !(locks() && typeof BroadcastChannel === "function")) return Connection.open(url, {
+			...options,
+			shape: "browser"
+		});
+		const t = new ConnectionTabs(url, options);
+		await t.start(shared);
+		return t;
+	}
+	constructor(url, options) {
+		this.url = url;
+		this.options = options;
+		this.name = options.name ?? new URL(url).host;
+		this.id = rid();
+		this.n = 0;
+		this.tagN = 0;
+		this.base = url.replace(/^ws/u, "http");
+		this.token = options.token ?? "";
+		this.units = 1;
+		this.dir = null;
+		this.calls = /* @__PURE__ */ new Map();
+		this.subs = /* @__PURE__ */ new Map();
+		this.link = null;
+		this.closed = false;
+	}
+	async start(shared) {
+		this.releaseTab = locks() ? await hold(`db-tab:${this.id}`) : null;
+		if (typeof addEventListener === "function") addEventListener("pagehide", () => this.post({ bye: true }));
+		const first = new Promise((ok, fail) => {
+			this.started = {
+				ok,
+				fail
+			};
+		});
+		if (shared) {
+			const sw = new SharedWorker(this.options.worker, {
+				type: "module",
+				name: `db:${this.name}`
+			});
+			this.port = sw.port;
+			this.port.onmessage = (e) => this.received(e.data);
+			this.port.start?.();
+			this.attach((m) => this.port.postMessage(m));
+		} else this.elect();
+		return first;
+	}
+	/** Leader mode: wait for the lock (then lead); meanwhile follow whoever leads. */
+	elect() {
+		this.channel = new BroadcastChannel(`db-tabs:${this.name}`);
+		this.channel.onmessage = (e) => this.heard(e.data);
+		locks().request(`db-leader:${this.name}`, () => this.lead());
+		this.channel.postMessage({ who: true });
+	}
+	heard(m) {
+		if (m.who && this.host) this.channel.postMessage({ leader: this.id });
+		else if (m.leader && m.leader !== this.leaderId && !this.host) {
+			this.leaderId = m.leader;
+			this.attach((msg) => this.channel.postMessage({
+				to: m.leader,
+				from: this.id,
+				msg
+			}));
+		} else if (m.to === this.id && m.msg) this.host ? this.host.handle(m.from, m.msg, (x) => this.channel.postMessage({
+			to: m.from,
+			from: this.id,
+			msg: x
+		})) : this.received(m.msg);
+	}
+	/** This tab leads: its own Connection, its own calls straight to it; the others are told. */
+	lead() {
+		if (this.closed) return void 0;
+		const { worker: _w, name: _n, ...local } = this.options;
+		this.host = new TabsHost(local);
+		this.host.self = /* @__PURE__ */ new Set([this.id]);
+		this.leaderId = this.id;
+		this.attach((msg) => this.host.handle(this.id, msg, (x) => queueMicrotask(() => this.received(x))));
+		this.channel.postMessage({ leader: this.id });
+		return new Promise((stepDown) => {
+			this.stepDown = stepDown;
+		});
+	}
+	/** A new owner of the Connection: hello, then every watch and unanswered call again (same ids, same tags). */
+	attach(link) {
+		this.link = link;
+		const o = this.options;
+		link({
+			hello: {
+				url: this.url,
+				opts: Object.fromEntries(OPEN.filter((k) => o[k] !== void 0).map((k) => [k, o[k]])),
+				refresh: !!o.refresh
+			},
+			tab: this.id
+		});
+		for (const s of this.subs.values()) link(s.msg);
+		for (const c of this.calls.values()) link(c.msg);
+	}
+	post(msg) {
+		this.link?.(msg);
+	}
+	received(m) {
+		if (m.state !== void 0) {
+			if (m.state) {
+				this.dir = m.state.dir;
+				this.esc = m.state.esc;
+				this.token = m.state.token;
+				this.stats = m.state.stats;
+				this.started?.ok();
+			} else this.started?.fail(rebuild(m.error));
+			this.started = null;
+			return;
+		}
+		if (m.s !== void 0) {
+			this.subs.get(m.s)?.listener(m.view, m.meta);
+			return;
+		}
+		if (m.refresh !== void 0) {
+			Promise.resolve().then(() => this.options.refresh()).then((token) => this.post({
+				refreshed: m.refresh,
+				token
+			}), (e) => this.post({
+				refreshed: m.refresh,
+				error: errorOf(e)
+			}));
+			return;
+		}
+		const c = this.calls.get(m.id);
+		if (!c) return;
+		this.calls.delete(m.id);
+		if (m.error) c.fail(rebuild(m.error));
+		else c.ok(m.value);
+	}
+	call(name, args) {
+		if (TAGGED[name] !== void 0) {
+			const k = TAGGED[name];
+			args = [...args];
+			while (args.length < k) args.push(void 0);
+			args[k] = {
+				...args[k] ?? {},
+				tag: args[k]?.tag ?? `${this.id}:${this.tagN += 1}`
+			};
+		}
+		const msg = {
+			id: this.n += 1,
+			call: name,
+			args
+		};
+		return new Promise((ok, fail) => {
+			this.calls.set(msg.id, {
+				msg,
+				ok,
+				fail
+			});
+			this.post(msg);
+		});
+	}
+	sub(name, args, at, listener) {
+		const a = [...args];
+		a[at] = null;
+		const msg = {
+			id: this.n += 1,
+			sub: name,
+			args: a,
+			at
+		};
+		this.subs.set(msg.id, {
+			msg,
+			listener
+		});
+		this.post(msg);
+		return () => {
+			if (this.subs.delete(msg.id)) this.post({ unsub: msg.id });
+		};
+	}
+	get(...a) {
+		return this.call("get", a);
+	}
+	set(...a) {
+		return this.call("set", a);
+	}
+	take(...a) {
+		return this.call("take", a);
+	}
+	mutation(...a) {
+		return this.call("mutation", a);
+	}
+	query(...a) {
+		return this.call("query", a);
+	}
+	range(...a) {
+		return this.call("range", a);
+	}
+	upload(...a) {
+		return this.call("upload", a);
+	}
+	refreshDir() {
+		return this.call("refreshDir", []);
+	}
+	renew(reopen) {
+		return this.call("renew", [reopen]);
+	}
+	watch(q, unit, listener) {
+		return this.sub("watch", [q, unit], 2, listener);
+	}
+	watchRow(tb, id, listener) {
+		return this.sub("watchRow", [tb, id], 2, listener);
+	}
+	watchRange(tb, index, o, listener, options) {
+		return this.sub("watchRange", [
+			tb,
+			index,
+			o,
+			null,
+			options
+		], 3, listener);
+	}
+	watchQuery(name, args, options, listener) {
+		return this.sub("watchQuery", [
+			name,
+			args,
+			options
+		], 3, listener);
+	}
+	watchQueryAll(name, args, listener) {
+		return this.sub("watchQueryAll", [name, args], 2, listener);
+	}
+	everyUnit(q, onParts) {
+		return this.sub("everyUnit", [q], 1, onParts);
+	}
+	unitOf(id) {
+		return Connection.prototype.unitOf.call(this, id);
+	}
+	unitNames() {
+		return Connection.prototype.unitNames.call(this);
+	}
+	auth() {
+		return Connection.prototype.auth.call(this);
+	}
+	fileUrl(id) {
+		return Connection.prototype.fileUrl.call(this, id);
+	}
+	/** This tab leaves: its watches stop; a leader hands the Connection to the next tab (after its store is written). */
+	async close() {
+		if (this.closed) return;
+		this.closed = true;
+		this.post({ bye: true });
+		if (this.host) {
+			await this.host.close();
+			this.stepDown?.();
+		}
+		this.channel?.close();
+		this.port?.close?.();
+		this.releaseTab?.();
+	}
+};
+//#endregion
+export { ConnectionTabs };

package/vector/contract.d.mts

@@ -0,0 +1,10 @@
+import { g as VectorEngine, m as VectorControl } from "../index-DdoK0y7D.mjs";
+//#region src/vector/contract.d.ts
+interface VectorContractCase {
+  /** A line of the specification. */
+  readonly name: string;
+  run(engine: VectorEngine & VectorControl): Promise<void>;
+}
+declare const vectorContract: ReadonlyArray<VectorContractCase>;
+//#endregion
+export { VectorContractCase, vectorContract };