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

package/socket.mjs

@@ -0,0 +1,263 @@
+import { h as StorageError } from "./names-DfCBKupJ.mjs";
+import { streamsOf } from "./index.mjs";
+import { repeatable, serve } from "./wire.mjs";
+//#region src/socket.ts
+/**
+* Storage's wire over a WebSocket: one connection carries every call, so a client pays for one HTTP
+* request when it connects, not one a call. The frames are the wire's own (`@midsummer-ai/sdk/wire`),
+* each sent with a request id, replied to in any order; `remote` batches over it as over HTTP.
+*
+*   const files = storage(remote(socket("wss://api.<site>/storage/socket", { key, secret }), { batch: true }))
+*   // an app uses `client` (`@midsummer-ai/sdk/client`): this over one connection, with signed HTTP behind it
+*   // on the server, a session a connection:
+*   const session = socketSession({ engine, credentials })
+*   ws.send(session.greeting); ws.onmessage = async (m) => { const reply = await session.receive(m.data); if (reply) ws.send(reply) }
+*
+* A connection opens with a challenge: the server sends a random one, and the client replies with its
+* Storage Key's id and the HMAC-SHA256 of the challenge under its secret, so the secret never travels.
+* Then each message is a 4-byte little-endian request id followed by a frame, both ways. The key
+* reaches what it would over S3: its own Buckets, by name, writing only if it may and while its
+* Bucket's writes are not paused. A connection lives a minute, or 4,000 calls: the server then says it is closing,
+* replies to what it was sent, and closes, and the client opens a new one for its next call, so a key
+* revoked or a Bucket paused reaches every connection within a minute.
+*/
+const encoder = new TextEncoder();
+const SOCKET_LIFE_MS = 6e4;
+const SOCKET_FRAMES = 4e3;
+const SESSION_CONCURRENCY = 32;
+const hex = (bytes) => [...new Uint8Array(bytes)].map((b) => b.toString(16).padStart(2, "0")).join("");
+async function sign(secret, challenge) {
+	const key = await crypto.subtle.importKey("raw", encoder.encode(secret), {
+		name: "HMAC",
+		hash: "SHA-256"
+	}, false, ["sign"]);
+	return hex(await crypto.subtle.sign("HMAC", key, encoder.encode(challenge)));
+}
+function sameHex(a, b) {
+	if (a.length !== b.length) return false;
+	let difference = 0;
+	for (let i = 0; i < a.length; i += 1) difference |= a.charCodeAt(i) ^ b.charCodeAt(i);
+	return difference === 0;
+}
+/** The id and frame of a message, or a message from them. */
+function tagged(id, frame) {
+	const message = new Uint8Array(4 + frame.length);
+	new DataView(message.buffer).setUint32(0, id, true);
+	message.set(frame, 4);
+	return message;
+}
+const CONNECT_MS = 1e4;
+const FALLBACK_MS = 6e4;
+const SENDS = 3;
+const OPEN = 1;
+/** A connection that never opened: nothing was sent on it, so the call may go another way. */
+var Unreached = class extends StorageError {
+	constructor() {
+		super("unavailable", "Storage could not be reached");
+	}
+};
+/**
+* A transport over WebSockets to `url` (`connections` of them, 16 when not given), each call sent on
+* the one with the fewest calls in flight: one connection is one invocation on the server, so a few
+* carry more at once. Each opens on its first call and again after it closes. A call in flight when its
+* connection drops (a server going away on deploy closes every connection) is sent again on a new one
+* when the wire says repeating it is safe (`repeatable`), and is otherwise `unavailable`, since it may
+* have been carried out. Where no connection opens, or the runtime has no WebSocket, calls go over
+* `fallback` for a minute, then a connection is tried again; without one they are `unavailable`.
+*/
+function socket(url, options) {
+	const lines = Array.from({ length: options.connections ?? 16 }, () => line(url, options));
+	const { fallback } = options;
+	const clock = options.clock ?? Date.now;
+	const noSocket = !options.WebSocket && typeof globalThis.WebSocket !== "function";
+	let socketAfter = 0;
+	return {
+		async send(frame) {
+			if (fallback && (noSocket || clock() < socketAfter)) return fallback.send(frame);
+			if (noSocket) throw new Unreached();
+			try {
+				return await lines.reduce((least, one) => one.inFlight() < least.inFlight() ? one : least).send(frame);
+			} catch (error) {
+				if (!(error instanceof Unreached) || !fallback) throw error;
+				socketAfter = clock() + FALLBACK_MS;
+				return fallback.send(frame);
+			}
+		},
+		close() {
+			for (const one of lines) one.close();
+		}
+	};
+}
+/** One connection of a socket transport. */
+function line(url, options) {
+	const Socket = options.WebSocket ?? globalThis.WebSocket;
+	const waiting = /* @__PURE__ */ new Map();
+	let open = null;
+	let next = 0;
+	function connect() {
+		if (open) return open;
+		let ws;
+		try {
+			ws = new Socket(url);
+		} catch {
+			return Promise.reject(new Unreached());
+		}
+		const opening = new Promise((ready, refused) => {
+			ws.binaryType = "arraybuffer";
+			const late = setTimeout(() => (closed(), ws.close(1e3, "too slow")), CONNECT_MS);
+			const lost = (error) => {
+				clearTimeout(late);
+				open = null;
+				refused(error);
+				ws.close(1e3, "refused");
+			};
+			ws.addEventListener("message", (event) => {
+				if (typeof event.data === "string") {
+					const said = JSON.parse(event.data);
+					if (said.challenge !== void 0) sign(options.secret, said.challenge).then((signature) => ws.send(JSON.stringify({
+						key: options.key,
+						signature
+					})));
+					else if (said.ready) clearTimeout(late), ready(ws);
+					else if (said.closing) open = null;
+					else lost(new StorageError("forbidden", said.refused ?? "Storage refused the key"));
+					return;
+				}
+				const message = new Uint8Array(event.data);
+				const id = new DataView(message.buffer, message.byteOffset).getUint32(0, true);
+				waiting.get(id)?.done(message.subarray(4));
+				waiting.delete(id);
+			});
+			const closed = () => {
+				clearTimeout(late);
+				if (open === opening) open = null;
+				refused(new Unreached());
+				for (const [id, call] of waiting) if (call.on === ws) waiting.delete(id), call.lost();
+			};
+			ws.addEventListener("close", closed);
+			ws.addEventListener("error", closed);
+		});
+		return open = opening;
+	}
+	return {
+		inFlight: () => waiting.size,
+		async send(frame) {
+			for (let sends = 0;;) {
+				const opening = connect();
+				const ws = await opening;
+				const id = next = next + 1 >>> 0;
+				const sent = ws.readyState === OPEN;
+				const answer = await new Promise((done) => {
+					waiting.set(id, {
+						on: ws,
+						done,
+						lost: () => done(null)
+					});
+					if (sent) ws.send(tagged(id, frame));
+					else waiting.delete(id), done(null);
+				});
+				if (answer) return answer;
+				if (!sent) {
+					if (open === opening) open = null;
+					continue;
+				}
+				sends += 1;
+				if (!repeatable(frame)) throw new StorageError("unavailable", "The connection to Storage closed before it answered; the call may have been carried out");
+				if (sends === SENDS) throw new StorageError("unavailable", "The connection to Storage closed before it answered");
+			}
+		},
+		close() {
+			open?.then((ws) => ws.close(1e3, "done"), () => {});
+		}
+	};
+}
+/**
+* `engine` as a Storage Key reaches it: its Buckets by name (every Bucket, under its own name, when it
+* names none), reading always, writing only with `write` access and while the Bucket's writes are not
+* paused. Metering is the platform's, never a key's.
+*/
+function keyed(engine, credential) {
+	const id = (name) => {
+		const map = credential.buckets;
+		if (!map) return name;
+		if (!Object.hasOwn(map, name)) throw new StorageError("forbidden", `The key may not use the Bucket ${name}`);
+		return map[name];
+	};
+	const writable = (name) => {
+		if (credential.access !== "write") throw new StorageError("forbidden", "The key may only read");
+		if (credential.paused?.includes(name)) throw new StorageError("quota", `Writes to the Bucket ${name} are paused: its Team reached its budget`);
+		return id(name);
+	};
+	const metering = async () => {
+		throw new StorageError("forbidden", "Metering is not answered to a key");
+	};
+	return {
+		put: (bucket, ...rest) => engine.put(writable(bucket), ...rest),
+		get: (bucket, ...rest) => engine.get(id(bucket), ...rest),
+		head: (bucket, ...rest) => engine.head(id(bucket), ...rest),
+		delete: (bucket, ...rest) => engine.delete(writable(bucket), ...rest),
+		list: (bucket, ...rest) => engine.list(id(bucket), ...rest),
+		copy: (bucket, ...rest) => engine.copy(writable(bucket), ...rest),
+		createUpload: (bucket, ...rest) => engine.createUpload(writable(bucket), ...rest),
+		uploadPart: (bucket, ...rest) => engine.uploadPart(writable(bucket), ...rest),
+		completeUpload: (bucket, ...rest) => engine.completeUpload(writable(bucket), ...rest),
+		abortUpload: (bucket, ...rest) => engine.abortUpload(writable(bucket), ...rest),
+		usage: metering,
+		operations: metering,
+		...streamsOf(engine, id, writable)
+	};
+}
+/** A server's side of one connection: the handshake against `credentials`, then each frame served by `engine` as the key reaches it. */
+function socketSession(options) {
+	const challenge = hex(crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(32)).buffer);
+	let answer = null;
+	let closing = false, inFlight = 0, frames = 0, drained = null;
+	const turns = [];
+	let settle;
+	const settled = new Promise((resolve) => settle = resolve);
+	return {
+		greeting: JSON.stringify({ challenge }),
+		closing: JSON.stringify({ closing: true }),
+		life: SOCKET_LIFE_MS,
+		spent: () => frames >= SOCKET_FRAMES,
+		idle() {
+			closing = true;
+			return inFlight === 0 ? Promise.resolve() : new Promise((resolve) => drained = resolve);
+		},
+		settled,
+		async receive(message) {
+			if (typeof message === "string") {
+				if (answer) return null;
+				let said;
+				try {
+					said = JSON.parse(message);
+				} catch {
+					said = {};
+				}
+				const credential = typeof said.key === "string" ? await options.credentials(said.key) : null;
+				if (!credential || typeof said.signature !== "string" || !sameHex(await sign(credential.secret, challenge), said.signature)) {
+					settle("refused");
+					return JSON.stringify({ refused: "The key is unknown, or the signature does not match" });
+				}
+				answer = serve(keyed(options.engine, credential));
+				settle("ready");
+				return JSON.stringify({ ready: true });
+			}
+			if (!answer) return null;
+			const bytes = message instanceof Uint8Array ? message : message instanceof Blob ? new Uint8Array(await message.arrayBuffer()) : new Uint8Array(message);
+			const id = new DataView(bytes.buffer, bytes.byteOffset).getUint32(0, true);
+			inFlight += 1;
+			frames += 1;
+			if (inFlight > SESSION_CONCURRENCY) await new Promise((go) => turns.push(go));
+			try {
+				return tagged(id, await answer(bytes.subarray(4)));
+			} finally {
+				inFlight -= 1;
+				turns.shift()?.();
+				if (closing && inFlight === 0) drained?.();
+			}
+		}
+	};
+}
+//#endregion
+export { keyed, sameHex, sign, socket, socketSession };

package/stand-in.d.mts

@@ -0,0 +1,7 @@
+import { m as StorageEngine } from "./index-sgdyoA2P.mjs";
+//#region src/stand-in.d.ts
+declare function standIn(options: {
+  readonly clock: () => number;
+}): StorageEngine;
+//#endregion
+export { standIn };

package/stand-in.mjs

@@ -0,0 +1,185 @@
+import { f as resolveRange, h as StorageError, m as sha256, p as sameSizes, u as compareKeys } from "./names-DfCBKupJ.mjs";
+//#region src/stand-in.ts
+/**
+* Storage's Stand-in: the Capability's behaviour in memory, for `midsummer dev` and tests. It holds
+* no engine code and passes the contract (`@midsummer-ai/sdk/contract`) except durability and scale.
+*
+*   const files = storage(standIn({ clock: Date.now }))
+*
+* A Bucket exists from its first put. Everything is lost when the process ends.
+*/
+function standIn(options) {
+	const buckets = /* @__PURE__ */ new Map();
+	const calls = /* @__PURE__ */ new Map();
+	const count = (bucket, write) => {
+		let list = calls.get(bucket);
+		if (!list) calls.set(bucket, list = []);
+		list.push({
+			at: options.clock(),
+			write
+		});
+	};
+	const uploads = /* @__PURE__ */ new Map();
+	const uploadOf = (bucket, key, uploadId) => {
+		const upload = uploads.get(uploadId);
+		if (!upload || upload.bucket !== bucket || upload.key !== key) throw new StorageError("not_found", "no such upload, or it is finished", "upload");
+		return upload;
+	};
+	const bucketOf = (name) => {
+		let bucket = buckets.get(name);
+		if (!bucket) buckets.set(name, bucket = /* @__PURE__ */ new Map());
+		return bucket;
+	};
+	const read = (held, range) => {
+		if (!range) return {
+			...held.object,
+			body: held.body.slice()
+		};
+		const at = resolveRange(range, held.object.size);
+		return {
+			...held.object,
+			body: held.body.slice(at.offset, at.offset + at.length),
+			range: at
+		};
+	};
+	const engine = {
+		async put(bucket, key, body, put) {
+			count(bucket, true);
+			const current = buckets.get(bucket)?.get(key);
+			if (put.ifNoneMatch && current) throw new StorageError("conflict", `"${key}" already holds an Object`);
+			if (put.ifMatch !== void 0 && current?.object.etag !== put.ifMatch) throw new StorageError("conflict", `"${key}" does not hold the etag ${put.ifMatch}`);
+			const object = {
+				key,
+				size: body.length,
+				etag: await sha256(body),
+				contentType: put.contentType,
+				metadata: { ...put.metadata },
+				uploadedAt: options.clock()
+			};
+			bucketOf(bucket).set(key, {
+				object,
+				body: body.slice()
+			});
+			return object;
+		},
+		async get(bucket, key, range, limit) {
+			count(bucket, false);
+			const held = buckets.get(bucket)?.get(key);
+			if (!held) return null;
+			return read(held, range ?? (limit !== void 0 && held.body.length > limit ? {
+				offset: 0,
+				length: limit
+			} : void 0));
+		},
+		async head(bucket, key) {
+			count(bucket, false);
+			return buckets.get(bucket)?.get(key)?.object ?? null;
+		},
+		async delete(bucket, key) {
+			count(bucket, true);
+			buckets.get(bucket)?.delete(key);
+		},
+		async list(bucket, { prefix, delimiter, after, limit }) {
+			count(bucket, false);
+			const keys = [...buckets.get(bucket)?.keys() ?? []].filter((key) => key.startsWith(prefix)).sort(compareKeys);
+			const objects = [], prefixes = [];
+			let last;
+			for (const key of keys) {
+				if (after !== void 0 && (compareKeys(key, after) <= 0 || delimiter !== void 0 && after.endsWith(delimiter) && key.startsWith(after))) continue;
+				const cut = delimiter === void 0 ? -1 : key.indexOf(delimiter, prefix.length);
+				const folded = cut === -1 ? void 0 : key.slice(0, cut + delimiter.length);
+				if (folded !== void 0 && folded === prefixes.at(-1)) continue;
+				if (objects.length + prefixes.length === limit) return {
+					objects,
+					prefixes,
+					next: last
+				};
+				if (folded !== void 0) prefixes.push(last = folded);
+				else objects.push(buckets.get(bucket).get(last = key).object);
+			}
+			return {
+				objects,
+				prefixes
+			};
+		},
+		async copy(bucket, from, to, copy) {
+			count(bucket, true);
+			const source = buckets.get(bucket)?.get(from);
+			if (!source) throw new StorageError("not_found", `"${from}" holds nothing`);
+			if (copy.ifNoneMatch && buckets.get(bucket)?.has(to)) throw new StorageError("conflict", `"${to}" already holds an Object`);
+			const object = {
+				...source.object,
+				key: to,
+				uploadedAt: options.clock()
+			};
+			bucketOf(bucket).set(to, {
+				object,
+				body: source.body
+			});
+			return object;
+		},
+		async createUpload(bucket, key, upload) {
+			count(bucket, true);
+			const uploadId = crypto.randomUUID();
+			uploads.set(uploadId, {
+				bucket,
+				key,
+				options: upload,
+				parts: /* @__PURE__ */ new Map()
+			});
+			return { uploadId };
+		},
+		async uploadPart(bucket, key, uploadId, partNumber, body) {
+			count(bucket, true);
+			const upload = uploadOf(bucket, key, uploadId);
+			const part = {
+				partNumber,
+				etag: await sha256(body),
+				size: body.length
+			};
+			upload.parts.set(partNumber, {
+				part,
+				body: body.slice()
+			});
+			return part;
+		},
+		async completeUpload(bucket, key, uploadId, named) {
+			const upload = uploadOf(bucket, key, uploadId);
+			const parts = named.map(({ partNumber, etag }, i) => {
+				const sent = upload.parts.get(partNumber);
+				if (!sent || sent.part.etag !== etag) throw new StorageError("invalid", `part ${partNumber} was not sent with that etag`, "part");
+				if (i < named.length - 1 && sent.part.size < 5242880) throw new StorageError("invalid", `part ${partNumber} is smaller than 5 MiB and is not the last`, "part-too-small");
+				return sent.body;
+			});
+			sameSizes(parts.map((p) => p.length), named);
+			const whole = new Uint8Array(parts.reduce((n, p) => n + p.length, 0));
+			let at = 0;
+			for (const p of parts) whole.set(p, at), at += p.length;
+			const object = await engine.put(bucket, key, whole, upload.options);
+			uploads.delete(uploadId);
+			return object;
+		},
+		async abortUpload(bucket, key, uploadId) {
+			count(bucket, true);
+			uploadOf(bucket, key, uploadId);
+			uploads.delete(uploadId);
+		},
+		async operations(bucket, from, to) {
+			const window = (calls.get(bucket) ?? []).filter((call) => call.at >= from && call.at < to);
+			return {
+				reads: window.filter((call) => !call.write).length,
+				writes: window.filter((call) => call.write).length
+			};
+		},
+		async usage(bucket) {
+			const held = [...buckets.get(bucket)?.values() ?? []];
+			return {
+				objects: held.length,
+				bytes: held.reduce((sum, { object }) => sum + object.size, 0)
+			};
+		}
+	};
+	return engine;
+}
+//#endregion
+export { standIn };

package/store-BzI9at5x.mjs

@@ -0,0 +1,237 @@
+import "./connection-CDk7H1FL.mjs";
+//#region src/database/client/store.mjs
+const STORES = [
+	"ops",
+	"views",
+	"meta"
+];
+/** A store in IndexedDB database `db:<name>`. */
+function idbStore(name, options) {
+	return new ConnectionStore(idbBackend(name), options);
+}
+var ConnectionStore = class {
+	/** `backend`: `{ load() -> { ops: [record], views: [[key, record]], meta: { k: v } }, write(batch) -> Promise }`. */
+	constructor(backend, { delay = 50, views = 2e3, onResumed = null } = {}) {
+		this.backend = backend;
+		this.delay = delay;
+		this.maxViews = views;
+		this.onResumed = onResumed;
+		this.ops = /* @__PURE__ */ new Map();
+		this.views = /* @__PURE__ */ new Map();
+		this.rows = /* @__PURE__ */ new Map();
+		this.seq = 0;
+		this.dirV = -1;
+		this.resumed = [];
+		this.batch = null;
+		this.timer = null;
+		this.writing = Promise.resolve();
+	}
+	/** Called by Connection.connect before the socket opens: loads, routes by the stored map, queues the stored ops. */
+	async attach(g) {
+		this.g = g;
+		const { ops, views, meta } = await this.backend.load();
+		if (meta.dir) {
+			g.setDir(meta.dir);
+			this.dirV = meta.dir.v;
+		}
+		if (meta.esc && !g.esc) g.esc = meta.esc;
+		for (const [key, rec] of views) {
+			this.views.set(key, rec);
+			this.indexRow(rec);
+		}
+		ops.sort((x, y) => x.seq - y.seq);
+		for (const rec of ops) {
+			this.seq = Math.max(this.seq, rec.seq);
+			if (rec.at && Date.now() - rec.at > 864e5) {
+				this.del("ops", rec.t);
+				const answer = Promise.resolve({
+					ok: false,
+					why: "expired",
+					t: rec.t,
+					sentAt: rec.at
+				});
+				this.resumed.push({
+					op: rec.op,
+					answer
+				});
+				if (this.onResumed) this.onResumed(rec.op, answer);
+				continue;
+			}
+			this.ops.set(rec.t, rec);
+			const answer = g.send(g.unitOf(rec.route ?? ""), { ...rec.op }, true, null, rec.route);
+			this.resumed.push({
+				op: rec.op,
+				answer
+			});
+			if (this.onResumed) this.onResumed(rec.op, answer);
+		}
+		if (typeof addEventListener === "function" && typeof document !== "undefined") {
+			addEventListener("pagehide", () => this.flush());
+			document.addEventListener("visibilitychange", () => {
+				if (document.visibilityState === "hidden") this.flush();
+			});
+		}
+	}
+	/** A tagged op that must land was issued (again: ignored). */
+	issued(op, route) {
+		if (this.ops.has(op.t)) return;
+		const { i: _i, ...plain } = op;
+		const rec = {
+			t: op.t,
+			seq: this.seq += 1,
+			op: plain,
+			route
+		};
+		this.ops.set(op.t, rec);
+		this.put("ops", op.t, rec);
+	}
+	/** First put on the wire: from now on its outcome is in doubt until answered. */
+	sent(op) {
+		const rec = this.ops.get(op.t);
+		if (rec && !rec.at) {
+			rec.at = Date.now();
+			this.put("ops", op.t, rec);
+		}
+	}
+	/** Its answer: kept while it waits for its durable receipt (`pend`), else done. */
+	answered(op, a) {
+		if (!a.pend) this.drop(op.t);
+	}
+	/** Its durable receipt. */
+	durable(op) {
+		if (op.t) this.drop(op.t);
+	}
+	drop(t) {
+		if (this.ops.delete(t)) this.del("ops", t);
+	}
+	/** A watch's new value (without any optimistic overlay). */
+	saw(w) {
+		const view = w.q.k === "g" ? w.state : this.g.view(w);
+		if (view === void 0) return;
+		const rec = {
+			q: w.q,
+			view
+		};
+		this.views.delete(w.key);
+		this.views.set(w.key, rec);
+		this.indexRow(rec);
+		this.put("views", w.key, rec);
+		while (this.views.size > this.maxViews) {
+			const old = this.views.keys().next().value;
+			this.views.delete(old);
+			this.del("views", old);
+		}
+	}
+	/** The stored value of a watch (a row view marked stale), or undefined. */
+	cached(w) {
+		const rec = this.views.get(w.key);
+		if (!rec) return void 0;
+		return w.q.k === "g" ? {
+			...rec.view,
+			stale: true
+		} : rec.view;
+	}
+	/** A row's last stored value `{ v, value }` (value null: gone), or undefined. */
+	row(key) {
+		return this.rows.get(key);
+	}
+	indexRow(rec) {
+		if (rec.q.k === "g") this.rows.set(`${rec.q.tb ?? "rows"}/${rec.q.id}`, rec.view.gone ? {
+			v: 0,
+			value: null
+		} : {
+			v: rec.view.v,
+			value: rec.view.value
+		});
+	}
+	put(store, key, value) {
+		const b = this.open(store);
+		b.del.delete(key);
+		b.put.set(key, value);
+	}
+	del(store, key) {
+		const b = this.open(store);
+		b.put.delete(key);
+		b.del.add(key);
+	}
+	open(store) {
+		this.batch ??= Object.fromEntries(STORES.map((s) => [s, {
+			put: /* @__PURE__ */ new Map(),
+			del: /* @__PURE__ */ new Set()
+		}]));
+		if (!this.timer) {
+			this.timer = setTimeout(() => this.flush(), this.delay);
+			this.timer.unref?.();
+		}
+		return this.batch[store];
+	}
+	/** Writes what changed in one transaction; resolves when it (and every write before it) is stored. */
+	flush() {
+		clearTimeout(this.timer);
+		this.timer = null;
+		const g = this.g;
+		if (g?.dir && g.dir.v > this.dirV) {
+			this.dirV = g.dir.v;
+			this.put("meta", "dir", g.dir);
+			if (g.esc) this.put("meta", "esc", g.esc);
+			clearTimeout(this.timer);
+			this.timer = null;
+		}
+		const batch = this.batch;
+		this.batch = null;
+		if (batch) this.writing = this.writing.then(() => this.backend.write(batch)).catch((e) => {
+			this.error = e;
+		});
+		return this.writing;
+	}
+	/** Flushes and stops (the Connection keeps running without it). */
+	async close() {
+		await this.flush();
+		this.backend.close?.();
+	}
+};
+const req = (r) => new Promise((ok, fail) => {
+	r.onsuccess = () => ok(r.result);
+	r.onerror = () => fail(r.error);
+});
+function idbBackend(name) {
+	let opened = null;
+	const db = () => opened ??= new Promise((ok, fail) => {
+		const r = indexedDB.open(`db:${name}`, 1);
+		r.onupgradeneeded = () => {
+			for (const s of STORES) if (!r.result.objectStoreNames.contains(s)) r.result.createObjectStore(s);
+		};
+		r.onsuccess = () => ok(r.result);
+		r.onerror = () => fail(r.error);
+	});
+	return {
+		async load() {
+			const t = (await db()).transaction(STORES, "readonly");
+			const all = (s) => Promise.all([req(t.objectStore(s).getAllKeys()), req(t.objectStore(s).getAll())]).then(([k, v]) => k.map((key, n) => [key, v[n]]));
+			const [ops, views, meta] = await Promise.all(STORES.map(all));
+			return {
+				ops: ops.map(([, v]) => v),
+				views,
+				meta: Object.fromEntries(meta)
+			};
+		},
+		async write(batch) {
+			const t = (await db()).transaction(STORES, "readwrite");
+			for (const s of STORES) {
+				const os = t.objectStore(s);
+				for (const [k, v] of batch[s].put) os.put(v, k);
+				for (const k of batch[s].del) os.delete(k);
+			}
+			await new Promise((ok, fail) => {
+				t.oncomplete = ok;
+				t.onerror = t.onabort = () => fail(t.error);
+			});
+		},
+		close() {
+			opened?.then((d) => d.close(), () => {});
+			opened = null;
+		}
+	};
+}
+//#endregion
+export { idbStore };