@spooky-sync/core 0.0.1-canary.330 → 0.0.1-canary.332

package/dist/index.js

@@ -2188,8 +2188,8 @@ function trimHistory(history, cap) {
 
 //#endregion
 //#region src/modules/devtools/index.ts
-const CORE_VERSION = "0.0.1-canary.330";
-const WASM_VERSION = "0.0.1-canary.330";
+const CORE_VERSION = "0.0.1-canary.332";
+const WASM_VERSION = "0.0.1-canary.332";
 const SURREAL_VERSION = "3.1.0";
 var DevToolsService = class DevToolsService {
 	version = CORE_VERSION;
@@ -4168,6 +4168,35 @@ function decideMembershipOutcome(input) {
 	return meta.rowCount === 0 && meta.state !== "materializing" ? "applied" : "ignored";
 }
 /**
+* Commit LIVE edge deltas onto a held id-set: each names a row that joined
+* (or moved to a newer version). Returns `held` itself when nothing moves.
+*/
+function withDeltas(held, deltas) {
+	const next = new Map(held);
+	let moved = false;
+	for (const { id, version } of deltas) {
+		if ((next.get(id) ?? -1) >= version) continue;
+		next.set(id, version);
+		moved = true;
+	}
+	return moved ? Array.from(next.entries()) : held;
+}
+/**
+* A membership read answers for the moment the server ran it, which may be
+* before a LIVE delta that was committed while the read was in flight. Carry
+* what changed in state since the read was sent (`before` -> `now`) over onto
+* the read, so a late answer never takes back a row that just joined.
+*/
+function rebaseRead(read, before, now) {
+	if (before === now) return read;
+	const was = new Map(before);
+	const is = new Map(now);
+	const out = new Map(read);
+	for (const [id] of before) if (!is.has(id)) out.delete(id);
+	for (const [id, version] of now) if (version > (was.get(id) ?? -1) && version > (out.get(id) ?? -1)) out.set(id, version);
+	return Array.from(out.entries());
+}
+/**
 * A statement that did not answer (an ERR, or no result at all). Kept apart
 * from a `null` result, which is the server saying "no such row": reading a
 * failed statement as a missing row turned every timeout under load into a
@@ -4854,9 +4883,38 @@ const stmt$1 = (results, i) => {
 	return r && r.status === "OK" ? r.result : FAILED;
 };
 /**
+* Commit LIVE edge deltas (rows joining a view, or moving to a newer
+* version) straight to membership, without re-reading the edges: the
+* notification already says what the read would. Returns the hashes it
+* settled; any other change still goes through {@link readMembership}.
+*
+* Only for a query whose membership is known and current (`live`, not
+* materializing, no view-lost recovery pending): before that the read decides
+* what the set is. Removals are never applied here, so a view whose edges
+* are being rewritten never loses (and garbage-collects) bodies mid-rewrite.
+* Nor for a query with a `LIMIT`: a row joining it pushes another out, and
+* rendering the joiner before the read removes the leaver would show one row
+* too many (the id-set render drops the `LIMIT`).
+*/
+function* applyEdgeDeltas(deltas) {
+	const settled = /* @__PURE__ */ new Set();
+	const byHash = /* @__PURE__ */ new Map();
+	for (const d of deltas) byHash.set(d.hash, [...byHash.get(d.hash) ?? [], d]);
+	for (const [hash, list] of byHash) {
+		const entry = yield fx.state.read((s) => s.queries.get(hash));
+		if (!entry || entry.lifecycle.phase !== "live" || entry.serverState === "materializing" || entry.viewLostRetryAt !== null) continue;
+		if (entry.def.plan ? entry.def.plan.limit != null : /\bLIMIT\b/i.test(entry.def.surql)) continue;
+		const next = withDeltas(entry.remoteArray, list);
+		if (next !== entry.remoteArray) yield* applyMembership(hash, next);
+		settled.add(hash);
+	}
+	return settled;
+}
+/**
 * Read the server membership of many queries in as few round trips as the
-* row budget allows, then apply each changed set. This is the ONLY place a
-* server id-set enters state: registration, the poll, LIVE dirt and view-lost
+* row budget allows, then apply each changed set. Every server id-set enters
+* state here, except the rows LIVE reports joining (see
+* {@link applyEdgeDeltas}): registration, the poll, LIVE dirt and view-lost
 * recovery all come through here.
 */
 function* readMembership(env, hashes, opts = {}) {
@@ -4919,9 +4977,10 @@ function* readMembership(env, hashes, opts = {}) {
 	for (const [hash, snap] of snapshots) {
 		const current = yield fx.state.read((s) => s.queries.get(hash));
 		if (!current) continue;
+		const primary = rebaseRead(snap.primary, byHash.get(hash).remoteArray, current.remoteArray);
 		const metaChanged = current.serverState !== (snap.meta.present ? snap.meta.state : null);
-		if (!recordVersionArraysEqual(snap.primary, current.remoteArray) || metaChanged || current.lifecycle.phase === "cold" || current.lifecycle.phase === "cached") {
-			const outcome = yield* applyMembership(hash, snap.primary, snap.meta);
+		if (!recordVersionArraysEqual(primary, current.remoteArray) || metaChanged || current.lifecycle.phase === "cold" || current.lifecycle.phase === "cached") {
+			const outcome = yield* applyMembership(hash, primary, snap.meta);
 			if (outcome === "applied") changed = true;
 			if (outcome === "ignored" && snap.meta.present && snap.meta.state === "materializing") stillMaterializing.push(hash);
 		}
@@ -6158,10 +6217,11 @@ function createInterpreter(adapters, host) {
 				const pending = adapters.remote.queryResponses(effect.sql, effect.vars);
 				return effect.timeoutMs ? withTimeout(pending, effect.timeoutMs, () => /* @__PURE__ */ new Error(`Remote request timed out after ${effect.timeoutMs}ms`)) : pending;
 			}
-			case "remote.live": return adapters.remote.live(effect.table, (hashes, rows) => host.dispatch({
+			case "remote.live": return adapters.remote.live(effect.table, (hashes, rows, deltas) => host.dispatch({
 				type: "LiveChange",
 				hashes,
-				rows
+				rows,
+				deltas
 			}));
 			case "remote.kill": return adapters.remote.kill(effect.uuid);
 			case "ssp.register": {
@@ -6711,9 +6771,10 @@ function* pollTick(env) {
 //#endregion
 //#region src/sync/live.saga.ts
 /**
-* LIVE on the session's `_00_list_ref` table. An event marks its query's
-* membership dirty and the batched re-read decides; followers get the same
-* dirt relayed by the leader.
+* LIVE on the session's `_00_list_ref` table. A row joining a live view is
+* committed straight from its edge; any other event marks its query's
+* membership dirty and the batched re-read decides. Followers get the dirt
+* relayed by the leader.
 *
 * When the subscription was opened with the body joined on
 * (`liveInlineBodies`) the event ALSO carries the changed row. That is an
@@ -6765,8 +6826,12 @@ function* liveInvalidate() {
 		liveTable: null
 	}));
 }
-/** One or more edges of these queries changed on the server. */
-function* liveChange(env, hashes, rows) {
+/**
+* One or more edges of these queries changed on the server. A row joining a
+* live view (`deltas`) is committed at once; anything else marks the query
+* dirty for the batched re-read.
+*/
+function* liveChange(env, hashes, rows, deltas) {
 	const [known, role, streak] = yield fx.state.read((s) => [
 		hashes.filter((h) => s.queries.has(h)),
 		s.tabRole,
@@ -6778,7 +6843,9 @@ function* liveChange(env, hashes, rows) {
 		yield fx.timer.set("poll", env.pollBaseMs, { type: "PollTick" });
 	}
 	if (rows && rows.length > 0) yield* landInlineRows(env, rows);
-	yield* markMembershipDirty(known);
+	const settled = deltas && deltas.length > 0 ? yield* applyEdgeDeltas(deltas.filter((d) => known.includes(d.hash))) : /* @__PURE__ */ new Set();
+	const dirty = known.filter((h) => !settled.has(h));
+	if (dirty.length > 0) yield* markMembershipDirty(dirty);
 	if (role === "leader") yield fx.emit({
 		type: "tabs:broadcast",
 		message: {
@@ -7326,7 +7393,7 @@ function route(env, event) {
 			lane: serial("live")
 		};
 		case "LiveChange": return {
-			saga: liveChange(env, event.hashes, event.rows),
+			saga: liveChange(env, event.hashes, event.rows, event.deltas),
 			lane: serial("live-change")
 		};
 		case "TabRole": return {
@@ -8544,6 +8611,11 @@ var RemoteDatabaseService = class extends AbstractDatabaseService {
 	setAuthToken(token) {
 		this.authToken = token;
 	}
+	/** The token the session is signed in with (or the configured one), for
+	*  calls that leave the socket: `r2` bucket files go to the SSP over HTTP. */
+	getAuthToken() {
+		return this.authToken ?? this.getConfig().token ?? null;
+	}
 	/** Resolved reconnect tunables; the supervisor reads its own knobs here. */
 	getReconnectConfig() {
 		return this.reconnectConfig;
@@ -12620,8 +12692,6 @@ function loadLoro() {
 const LOCAL_TABLE = "_00_crdt_local";
 const LOG_SUFFIX = "__crdt_log";
 const PRESENCE_SUFFIX = "__crdt_presence";
-/** Longest a burst of typing waits before its edits go out. */
-const MAX_WAIT_MS = 2e3;
 const PERSIST_DEBOUNCE_MS = 400;
 const PRESENCE_THROTTLE_MS = 250;
 const CLAIM_RETRY_MS = 5e3;
@@ -12643,11 +12713,12 @@ var CrdtManager = class {
 	claim = null;
 	claimRetry = null;
 	connectionUnsubscribes = [];
-	constructor(schema, local, remote, logger, debounceMs = 300) {
+	constructor(schema, local, remote, logger, debounceMs = 50, sendIntervalMs = 200) {
 		this.schema = schema;
 		this.local = local;
 		this.remote = remote;
 		this.debounceMs = debounceMs;
+		this.sendIntervalMs = sendIntervalMs;
 		this.logger = logger.child({ service: "CrdtManager" });
 		this.connectionUnsubscribes.push(this.remote.subscribeConnection("connected", () => {
 			for (const s of this.sessions.values()) {
@@ -12768,9 +12839,11 @@ var CrdtManager = class {
 			verifyTimer: null,
 			disposers: [],
 			flushTimer: null,
-			firstDirtyAt: 0,
+			flushDueAt: 0,
+			lastSentAt: 0,
 			persistTimer: null,
 			flushing: null,
+			flushQueued: null,
 			refetching: false,
 			presenceTimer: null,
 			presencePending: null,
@@ -12783,31 +12856,31 @@ var CrdtManager = class {
 		if (local.snapshot || fresh) session.handle.markLoaded();
 		this.sessions.set(key, session);
 		this.ensureClaimed();
-		if (!local.snapshot && !fresh) await this.serverWait(this.refetchCanonical(session));
+		const canonical = !local.snapshot && !fresh ? this.refetchCanonical(session) : null;
 		session.disposers.push(doc.subscribeLocalUpdates(() => {
 			session.local.peers[this.peer] ??= { enqueued: 0 };
 			this.scheduleFlush(session);
 			this.schedulePersist(session);
 		}));
 		const ports = this.ports;
-		const log = await ports.watch(`${table}${LOG_SUFFIX}`, {
+		const logWatch = ports.watch(`${table}${LOG_SUFFIX}`, {
 			doc: recordId,
 			field
 		}, (rows) => {
 			session.ingesting = session.ingesting.then(() => this.ingest(session, rows));
 		});
+		const presenceWatch = cursor ? ports.watch(`${table}${PRESENCE_SUFFIX}`, {
+			doc: recordId,
+			field
+		}, (rows) => this.ingestPresence(session, rows)) : null;
+		const [log, presence] = await Promise.all([logWatch, presenceWatch]);
 		session.disposers.push(log.stop);
+		if (presence) session.disposers.push(presence.stop);
 		log.settled.then(() => {
 			session.logSettled = true;
 			session.ingesting.then(() => this.checkLoaded(session));
 		});
-		if (cursor) {
-			const presence = await ports.watch(`${table}${PRESENCE_SUFFIX}`, {
-				doc: recordId,
-				field
-			}, (rows) => this.ingestPresence(session, rows));
-			session.disposers.push(presence.stop);
-		}
+		if (canonical) await this.serverWait(canonical);
 		if (!session.handle.hasContent() && !fresh) await this.serverWait(log.settled);
 		await session.ingesting;
 		this.scheduleFlush(session, 0);
@@ -12983,18 +13056,36 @@ var CrdtManager = class {
 			fork?.free();
 		}
 	}
-	scheduleFlush(s, delay = this.debounceMs) {
+	/**
+	* Arm the send. Edits go out on a steady cadence while they keep coming:
+	* the first one after a quiet spell waits `debounceMs` (one row for the
+	* burst), later ones at least `sendIntervalMs` after the previous send. An
+	* armed timer is never pushed back, so continuous typing cannot hold the
+	* edits; it is only brought forward (`delay`, e.g. 0 on reconnect).
+	*/
+	scheduleFlush(s, delay) {
 		const now = Date.now();
-		if (!s.flushTimer) s.firstDirtyAt = now;
-		else clearTimeout(s.flushTimer);
-		const wait = Math.max(0, Math.min(delay, s.firstDirtyAt + MAX_WAIT_MS - now));
+		const due = delay !== void 0 ? now + delay : Math.max(now + this.debounceMs, s.lastSentAt + this.sendIntervalMs);
+		if (s.flushTimer) {
+			if (s.flushDueAt <= due) return;
+			clearTimeout(s.flushTimer);
+		}
+		s.flushDueAt = due;
 		s.flushTimer = setTimeout(() => {
 			s.flushTimer = null;
 			this.flush(s);
-		}, wait);
-	}
-	async flush(s) {
-		if (s.flushing) return s.flushing;
+		}, due - now);
+	}
+	/** Send what is unsent. A call while a send runs queues one more after it,
+	*  so edits made during that send are not left waiting for the next edit. */
+	flush(s) {
+		if (s.flushing) {
+			s.flushQueued ??= s.flushing.then(() => {
+				s.flushQueued = null;
+				return this.flush(s);
+			});
+			return s.flushQueued;
+		}
 		s.flushing = this.sendOwnEdits(s).finally(() => {
 			s.flushing = null;
 		});
@@ -13012,6 +13103,7 @@ var CrdtManager = class {
 			from: s.local.peers[peer]?.enqueued ?? 0
 		})).filter((p) => p.end > p.from);
 		if (due.length === 0 || !this.ports) return;
+		s.lastSentAt = Date.now();
 		if (!await this.ensureClaimed()) {
 			this.retryLater(s);
 			return;
@@ -13046,7 +13138,8 @@ var CrdtManager = class {
 			}
 			s.local.peers[peer] = { enqueued: end };
 		}
-		await this.persist(s);
+		if (this.sessions.get(s.key) === s) this.schedulePersist(s);
+		else await this.persist(s);
 	}
 	retryLater(s) {
 		if (this.sessions.get(s.key) === s) this.scheduleFlush(s, CLAIM_RETRY_MS);
@@ -15079,6 +15172,27 @@ function rowOfEdge(value) {
 		record: out
 	};
 }
+/**
+* The membership change a `CREATE` or `UPDATE` notification reports: the
+* edge's target joined the view (or its version moved). Null for anything a
+* re-read must settle instead: a `DELETE` (a row leaving, or every edge of a
+* view being rewritten), a subquery child (`parent` set), or an edge missing
+* its target or version. With `FETCH out` the target is the joined row, whose
+* `id` is the record id.
+*/
+function deltaOfEdge(action, value) {
+	if (action !== "CREATE" && action !== "UPDATE") return null;
+	const hash = hashOfEdge(value);
+	const edge = value;
+	if (!hash || edge.parent != null || typeof edge.version !== "number") return null;
+	const out = edge.out instanceof RecordId$1 ? edge.out : edge.out?.id;
+	if (!(out instanceof RecordId$1)) return null;
+	return {
+		hash,
+		id: encodeRecordId(out),
+		version: edge.version
+	};
+}
 
 //#endregion
 //#region src/utils/blurhash.ts
@@ -15150,6 +15264,122 @@ function bucketContentToBlob(content) {
 	if (ArrayBuffer.isView(content)) return new Blob([content]);
 	return null;
 }
+/** A handle's settings from the client config and the bucket's generated schema. */
+function bucketSettings(config, name, logger) {
+	const backend = config.schema.buckets?.find((b) => b.name === name)?.backend;
+	return {
+		blurhash: config.blurhash,
+		logger,
+		backend,
+		files: config.files
+	};
+}
+/** `f"bucket:/path"` statements over the database connection. */
+function surrealIo(bucket, remote) {
+	const file = (path) => `f"${bucket}:/${path}"`;
+	return {
+		async put(path, content) {
+			await remote.query(`RETURN ${file(path)}.put($content);`, { content });
+		},
+		async get(path) {
+			const [result] = await remote.query(`RETURN ${file(path)}.get();`);
+			return result;
+		},
+		async delete(path) {
+			await remote.query(`RETURN ${file(path)}.delete();`);
+		},
+		async exists(path) {
+			const [result] = await remote.query(`RETURN ${file(path)}.exists();`);
+			return result;
+		},
+		async head(path) {
+			const [result] = await remote.query(`RETURN ${file(path)}.head();`);
+			return result;
+		},
+		async copy(sourcePath, targetPath) {
+			await remote.query(`RETURN ${file(sourcePath)}.copy($target);`, { target: targetPath });
+		},
+		async rename(sourcePath, targetPath) {
+			await remote.query(`RETURN ${file(sourcePath)}.rename($target);`, { target: targetPath });
+		},
+		async list(prefix) {
+			const [result] = await remote.query(`RETURN ${file(prefix)}.list();`);
+			return result;
+		}
+	};
+}
+/**
+* `BACKEND "r2"` buckets: the SSP keeps the files (R2 on Cloudflare, a
+* directory under `spky dev`) and serves them at `/bucket/<name>/<key>`,
+* after asking SurrealDB, as the signed-in user, whether the bucket's
+* PERMISSIONS clause allows it. The request carries the session's token.
+*/
+function sspIo(bucket, remote, endpoint) {
+	const base = () => {
+		if (!endpoint) throw new Error(`Bucket '${bucket}' is stored with the SSP (BACKEND "r2"): set \`files.endpoint\` in the client config to the SSP's URL.`);
+		return endpoint.replace(/\/+$/, "");
+	};
+	const url = (path) => `${base()}/bucket/${encodeURIComponent(bucket)}/${path.split("/").filter(Boolean).map(encodeURIComponent).join("/")}`;
+	const send = async (method, path, body, contentType) => {
+		const headers = {};
+		const token = remote.getAuthToken();
+		if (token) headers.Authorization = `Bearer ${token}`;
+		if (contentType) headers["Content-Type"] = contentType;
+		const response = await fetch(url(path), {
+			method,
+			headers,
+			body,
+			credentials: "omit"
+		});
+		if (!response.ok && response.status !== 404) {
+			let message = response.statusText;
+			try {
+				message = (await response.json()).error ?? message;
+			} catch {}
+			throw new Error(`Bucket '${bucket}' ${method} ${path} failed (${response.status}): ${message}`);
+		}
+		return response;
+	};
+	const op = async (path, body) => {
+		const response = await send("POST", path, JSON.stringify(body), "application/json");
+		if (response.status === 404) return null;
+		return await response.json();
+	};
+	const missing = (path) => /* @__PURE__ */ new Error(`Bucket '${bucket}': no file at ${path}`);
+	return {
+		async put(path, content) {
+			await send("PUT", path, content, (content instanceof Blob ? content.type : void 0) || "application/octet-stream");
+		},
+		async get(path) {
+			const response = await send("GET", path);
+			return response.status === 404 ? null : await response.blob();
+		},
+		async delete(path) {
+			await send("DELETE", path);
+		},
+		async exists(path) {
+			return await op(path, { op: "exists" }) ?? false;
+		},
+		async head(path) {
+			return await op(path, { op: "head" });
+		},
+		async copy(sourcePath, targetPath) {
+			if (await op(sourcePath, {
+				op: "copy",
+				target: targetPath
+			}) === null) throw missing(sourcePath);
+		},
+		async rename(sourcePath, targetPath) {
+			if (await op(sourcePath, {
+				op: "rename",
+				target: targetPath
+			}) === null) throw missing(sourcePath);
+		},
+		async list() {
+			throw new Error(`Bucket '${bucket}': listing is not available (BACKEND "r2")`);
+		}
+	};
+}
 /**
 * Paths known to have no blurhash sidecar, per tab. The blob cache has no
 * negative caching, so without this every mount of a hashless image would pay
@@ -15158,11 +15388,12 @@ function bucketContentToBlob(content) {
 */
 const missingBlurhash = /* @__PURE__ */ new Set();
 var BucketHandle = class {
+	io;
 	constructor(bucketName, remote, blobs, settings) {
 		this.bucketName = bucketName;
-		this.remote = remote;
 		this.blobs = blobs;
 		this.settings = settings;
+		this.io = settings?.backend === "r2" ? sspIo(bucketName, remote, settings.files?.endpoint) : surrealIo(bucketName, remote);
 	}
 	/** Effective blurhash setting: per-call option > client config > default ON. */
 	resolveBlurhash(option) {
@@ -15173,7 +15404,7 @@ var BucketHandle = class {
 	async put(path, content, options) {
 		const encodeOptions = this.resolveBlurhash(options?.blurhash);
 		const hashPromise = encodeOptions && isImagePath(path) ? encodeImageToBlurhash(content, encodeOptions) : Promise.resolve(null);
-		await this.remote.query(`RETURN f"${this.bucketName}:/${path}".put($content);`, { content });
+		await this.io.put(path, content);
 		await this.blobs?.invalidate({
 			bucket: this.bucketName,
 			path
@@ -15183,7 +15414,7 @@ var BucketHandle = class {
 			hash = await hashPromise;
 			if (hash) {
 				const sidecar = blurhashSidecarPath(path);
-				await this.remote.query(`RETURN f"${this.bucketName}:/${sidecar}".put($content);`, { content: hash });
+				await this.io.put(sidecar, hash);
 				await this.blobs?.invalidate({
 					bucket: this.bucketName,
 					path: sidecar
@@ -15231,8 +15462,7 @@ var BucketHandle = class {
 		}
 	}
 	async get(path) {
-		const [result] = await this.remote.query(`RETURN f"${this.bucketName}:/${path}".get();`);
-		return result;
+		return this.io.get(path);
 	}
 	/**
 	* Read through the local blob cache: OPFS first, the bucket second. Unlike
@@ -15286,7 +15516,7 @@ var BucketHandle = class {
 		})));
 	}
 	async delete(path) {
-		await this.remote.query(`RETURN f"${this.bucketName}:/${path}".delete();`);
+		await this.io.delete(path);
 		await this.blobs?.invalidate({
 			bucket: this.bucketName,
 			path
@@ -15294,7 +15524,7 @@ var BucketHandle = class {
 		if (isImagePath(path)) {
 			const sidecar = blurhashSidecarPath(path);
 			try {
-				await this.remote.query(`RETURN f"${this.bucketName}:/${sidecar}".delete();`);
+				await this.io.delete(sidecar);
 				await this.blobs?.invalidate({
 					bucket: this.bucketName,
 					path: sidecar
@@ -15304,23 +15534,19 @@ var BucketHandle = class {
 		}
 	}
 	async exists(path) {
-		const [result] = await this.remote.query(`RETURN f"${this.bucketName}:/${path}".exists();`);
-		return result;
+		return this.io.exists(path);
 	}
 	async head(path) {
-		const [result] = await this.remote.query(`RETURN f"${this.bucketName}:/${path}".head();`);
-		return result;
+		return this.io.head(path);
 	}
 	async copy(sourcePath, targetPath) {
-		await this.remote.query(`RETURN f"${this.bucketName}:/${sourcePath}".copy($target);`, { target: targetPath });
+		await this.io.copy(sourcePath, targetPath);
 	}
 	async rename(sourcePath, targetPath) {
-		await this.remote.query(`RETURN f"${this.bucketName}:/${sourcePath}".rename($target);`, { target: targetPath });
+		await this.io.rename(sourcePath, targetPath);
 	}
 	async list(prefix) {
-		const p = prefix ?? "";
-		const [result] = await this.remote.query(`RETURN f"${this.bucketName}:/${p}".list();`);
-		return result;
+		return this.io.list(prefix ?? "");
 	}
 };
 
@@ -15405,10 +15631,7 @@ function createServices(config) {
 	const local = createLocalEngine(config.localEngine, config.database, logger, { shared: tabsSupport.supported });
 	const remote = new RemoteDatabaseService(config.database, logger);
 	const connectionSupervisor = new ConnectionSupervisor(remote, logger);
-	const rawBucket = (name) => new BucketHandle(name, remote, null, {
-		blurhash: config.blurhash,
-		logger
-	});
+	const rawBucket = (name) => new BucketHandle(name, remote, null, bucketSettings(config, name, logger));
 	const blobs = createBlobCache({
 		local,
 		namespace: ANON_USER_ID,
@@ -15427,7 +15650,7 @@ function createServices(config) {
 	streamProcessor.configureCircuitPersistence(config.persistCircuit ?? config.localEngine === "sqlite", config.circuitCheckpointMs);
 	streamProcessor.configureProjection(config.circuitProjection ?? true);
 	const migrator = new LocalMigrator(local, logger);
-	const crdt = new CrdtManager(config.schema, local, remote, logger, config.crdtDebounceMs ?? 300);
+	const crdt = new CrdtManager(config.schema, local, remote, logger, config.crdtDebounceMs ?? 50, config.crdtSendIntervalMs ?? 200);
 	const auth = new AuthService(config.schema, remote, persistence, logger);
 	const tabId = typeof crypto !== "undefined" && crypto.randomUUID ? crypto.randomUUID() : `tab_${Math.random().toString(36).slice(2)}`;
 	return {
@@ -15453,7 +15676,7 @@ function createTabsCoordinator(config, s, host) {
 	return new TabsCoordinator({
 		tabId: s.tabId,
 		fingerprint: computeTabsFingerprint({
-			coreVersion: "0.0.1-canary.330",
+			coreVersion: "0.0.1-canary.332",
 			schemaHash: hash53(config.schemaSurql),
 			endpoint: config.database.endpoint ?? "",
 			namespace: config.database.namespace,
@@ -15673,7 +15896,8 @@ function createAdapters(config, s, host, lateModules) {
 					const hash = hashOfEdge(message.value);
 					if (!hash) return;
 					const row = message.action === "DELETE" ? null : rowOfEdge(message.value);
-					onChange([hash], row ? [row] : void 0);
+					const delta = deltaOfEdge(message.action, message.value);
+					onChange([hash], row ? [row] : void 0, delta ? [delta] : void 0);
 				});
 				return String(uuid);
 			},
@@ -16564,10 +16788,7 @@ var Sp00kyClient = class {
 		return this.services.crdt.close(table, recordId, field);
 	}
 	bucket(name) {
-		return new BucketHandle(name, this.services.remote, this.services.blobs, {
-			blurhash: this.config.blurhash,
-			logger: this.services.logger
-		});
+		return new BucketHandle(name, this.services.remote, this.services.blobs, bucketSettings(this.config, name, this.services.logger));
 	}
 	getBlobCacheStats() {
 		return this.services.blobs.stats();

package/dist/otel/index.d.ts

@@ -1,4 +1,4 @@
-import { p as PinoTransmit } from "../types.js";
+import { m as PinoTransmit } from "../types.js";
 import { Level } from "pino";
 
 //#region src/otel/index.d.ts

package/dist/pure.d.ts

@@ -139,6 +139,13 @@ interface InlineRow {
   version: number;
   record: Record<string, unknown>;
 }
+/**
+ * A row that joined a query's view, or moved to a newer version, as one LIVE
+ * notification on `_00_list_ref` reports it: the edge's `out` and `version`.
+ * The client commits it to the query's membership straight away instead of
+ * re-reading the edges (see `sync/live.saga.ts`).
+ */
+
 type RecordVersionArray = Array<[string, number]>;
 /**
  * Represents the difference between two record version sets.
@@ -329,6 +336,15 @@ declare function hashOfEdge(value: unknown): string | null;
  * `out: null`) and for an edge whose target has been deleted.
  */
 declare function rowOfEdge(value: unknown): InlineRow | null;
+/**
+ * The membership change a `CREATE` or `UPDATE` notification reports: the
+ * edge's target joined the view (or its version moved). Null for anything a
+ * re-read must settle instead: a `DELETE` (a row leaving, or every edge of a
+ * view being rewritten), a subquery child (`parent` set), or an edge missing
+ * its target or version. With `FETCH out` the target is the joined row, whose
+ * `id` is the record id.
+ */
+
 //#endregion
 //#region src/utils/parser.d.ts
 /**