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

package/AGENTS.md

@@ -38,7 +38,7 @@ re-materialized from state, never patched in place.
 - `BucketHandle` — file storage handle (`put`, `get`, `delete`, `exists`), plus the cache-aware `read`, `url`, `pin`/`unpin`, `evict`, `prefetch`. `get` is always remote; `read`/`url` go through the blob cache. A bucket generated with `backend: 'r2'` (`BACKEND "r2"`) sends its bytes to the SSP over HTTP (`<files.endpoint>/bucket/<name>/<path>`, bearer = the session token from `RemoteDatabaseService.getAuthToken()`) instead of `f"bucket:/path"` statements; the SSP checks `fn::_00_bucket::<name>` as the user first.
 - `services/blobs/` — durable cache for bucket bytes: OPFS holds the files, `_00_blob` holds a manifest that reconcile rebuilds from disk (so a wiped local store costs metadata, not the offline cache). Nothing expires on a timer; eviction is LRU under a byte budget only, skipping pinned and on-screen entries. Config: `blobCache` in `types.ts`.
 - `AuthService` — token management, sign-in/sign-out events. `subscribe(cb, { immediate? })` calls `cb` at once with the current user unless `immediate: false`, then on every change.
-- `CrdtManager`, `CrdtField`, `cursorColorFromName`, `CURSOR_COLORS`: collaborative `@crdt` fields on Loro. Client methods: `openCrdtField(table, recordId, field, draft?)` -> `Promise<CrdtField>` (every open of one field in a tab shares one `LoroDoc`; pair each with a close), `closeCrdtField(table, recordId, field)` -> `Promise<void>` (resolves once unsent edits are in the outbox; offline, once they are saved on the device, never waiting on the network), `createCrdtDraft(table, field)` -> a detached `CrdtField` for a record not created yet (`db.create` first, then pass it to `openCrdtField` as `draft`). `CrdtField`: `getDoc()`, `hasContent()`, `pushCursorState(bytes)`, `onCursorUpdate = cb` (a setter). Config: `crdt: true` preloads Loro, `crdtDebounceMs` (default 300, max wait 2 s). Design: `docs/crdt-v2.md` at the repo root.
+- `CrdtManager`, `CrdtField`, `cursorColorFromName`, `CURSOR_COLORS`: collaborative `@crdt` fields on Loro. Client methods: `openCrdtField(table, recordId, field, draft?)` -> `Promise<CrdtField>` (every open of one field in a tab shares one `LoroDoc`; pair each with a close), `closeCrdtField(table, recordId, field)` -> `Promise<void>` (resolves once unsent edits are in the outbox; offline, once they are saved on the device, never waiting on the network), `createCrdtDraft(table, field)` -> a detached `CrdtField` for a record not created yet (`db.create` first, then pass it to `openCrdtField` as `draft`). `CrdtField`: `getDoc()`, `hasContent()`, `pushCursorState(bytes)`, `onCursorUpdate = cb` (a setter). Config: `crdt: true` preloads Loro, `crdtDebounceMs` (the first edit after a quiet spell waits this long, default 50), `crdtSendIntervalMs` (shortest gap between two sends of one field while typing, default 200). Design: `docs/crdt-v2.md` at the repo root.
 - Types: `Sp00kyConfig` (client-solid wraps it as `SyncedDbConfig`), `QueryTimeToLive`, `PersistenceClient`, `StoreType`, `UpdateOptions`, `RunOptions`, `PreloadOptions`.
 - Subpath: `@spooky-sync/core/otel` — `createOtelTransmit(endpoint)` for piping pino logs to OpenTelemetry.
 - `client.webPush` (`WebPushModule`, `db.webPush` in the Solid bindings) - Web Push on the page: `support()`, `info()`, `subscribe(opts)` (call from a click), `unsubscribe(opts)`, `sync()`, `isSubscribed()`, `update(opts)`, `devices()`, `notify(msg)`, `cancel(id)`, `test()`, `bridge()`, `onMessage(cb)`. Server calls are `fn::push::*`; typed `WebPushError`; config `webPush` in `types.ts`. Sign-out runs through `AuthService.onBeforeSignOut`.

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { $ as WebPushSubscribeOptions, A as RunOptions, At as Logger$1, B as SyncHealthStatus, Bt as SESSION_POLL_MS, C as QueryTimeToLive, Ct as SignOutHook, D as RecordVersionArray, Dt as createAuthEventSystem, E as ReconnectConfig, Et as AuthEventTypes, F as StorageHealth, Ft as IMPERSONATION_ACCESS, G as WebPushConfig, Gt as sameImpersonation, H as UpdateOptions, Ht as decodeTokenClaims, I as StorageHealthStatus, It as ImpersonationInfo, J as WebPushErrorCode, K as WebPushDevice, L as StoreType, Lt as ImpersonationTimerHost, M as Sp00kyConfig, Mt as SealedQuery, N as Sp00kyQueryResult, Nt as EventDefinition, O as RecordVersionDiff, Ot as RemoteDatabaseService, P as Sp00kyQueryResultPromise, Pt as EventSystem, Q as WebPushModule, R as SyncHealth, Rt as ImpersonationTimers, S as QueryStatusCallback, St as SignOutContext, T as QueryUpdateCallback, Tt as AuthEventTypeMap, U as PUSH_ENDPOINT_KEY, Ut as impersonationFromToken, V as TimingPhase, Vt as TokenClaims, W as PushDeviceKind, Wt as renewDelayMs, X as WebPushMessage, Y as WebPushInfo, Z as WebPushMessageInput, _ as QueryConfig, _t as isPushPayload, a as Level, at as WebPushUpdateOptions, b as QueryState, bt as ImpersonationCandidate, c as MutationCallback, ct as BridgeTokenMessage, d as PersistenceClient, dt as PushNotificationAction, et as WebPushSupport, f as PhaseStat, ft as PushOp, g as QueryAuthorityCallback, gt as WebPushClientMessage, h as PreloadRefresh, ht as PushUrgency, i as InlineRow, it as WebPushUnsupportedReason, j as ServerViewMeta, jt as LocalStore, k as RegistrationTimings, kt as LogTap, l as MutationEvent, lt as PUSH_PAYLOAD_VERSION, m as PreloadOptions, mt as PushPayloadKind, n as DebounceOptions, nt as WebPushSyncStatus, o as MATERIALIZATION_SAMPLE_WINDOW, ot as detectWebPushSupport, p as PinoTransmit, pt as PushPayload, q as WebPushError, r as EventSubscriptionOptions, rt as WebPushUnsubscribeOptions, s as MembershipOutcome, st as BridgeSignOutMessage, t as ConnectionState, tt as WebPushSyncOptions, u as MutationEventType, ut as PushNotification, v as QueryConfigRecord, vt as ActiveImpersonation, w as QueryTimings, wt as AuthEventSystem, x as QueryStatus, xt as SIGN_OUT_HOOK_TIMEOUT_MS, y as QueryHash, yt as AuthService, z as SyncHealthConfig, zt as ORIGIN_TOKEN_KEY } from "./types.js";
+import { $ as WebPushModule, A as RegistrationTimings, At as LogTap, B as SyncHealthConfig, Bt as ORIGIN_TOKEN_KEY, C as QueryStatusCallback, Ct as SignOutContext, D as ReconnectConfig, Dt as AuthEventTypes, E as QueryUpdateCallback, Et as AuthEventTypeMap, F as Sp00kyQueryResultPromise, Ft as EventSystem, G as PushDeviceKind, Gt as renewDelayMs, H as TimingPhase, Ht as TokenClaims, I as StorageHealth, It as IMPERSONATION_ACCESS, J as WebPushError, K as WebPushConfig, Kt as sameImpersonation, L as StorageHealthStatus, Lt as ImpersonationInfo, M as ServerViewMeta, Mt as LocalStore, N as Sp00kyConfig, Nt as SealedQuery, O as RecordVersionArray, Ot as createAuthEventSystem, P as Sp00kyQueryResult, Pt as EventDefinition, Q as WebPushMessageInput, R as StoreType, Rt as ImpersonationTimerHost, S as QueryStatus, St as SIGN_OUT_HOOK_TIMEOUT_MS, T as QueryTimings, Tt as AuthEventSystem, U as UpdateOptions, Ut as decodeTokenClaims, V as SyncHealthStatus, Vt as SESSION_POLL_MS, W as PUSH_ENDPOINT_KEY, Wt as impersonationFromToken, X as WebPushInfo, Y as WebPushErrorCode, Z as WebPushMessage, _ as QueryAuthorityCallback, _t as WebPushClientMessage, a as InlineRow, at as WebPushUnsupportedReason, b as QueryHash, bt as AuthService, c as MembershipOutcome, ct as BridgeSignOutMessage, d as MutationEventType, dt as PushNotification, et as WebPushSubscribeOptions, f as PersistenceClient, ft as PushNotificationAction, g as PreloadRefresh, gt as PushUrgency, h as PreloadOptions, ht as PushPayloadKind, i as EventSubscriptionOptions, it as WebPushUnsubscribeOptions, j as RunOptions, jt as Logger$1, k as RecordVersionDiff, kt as RemoteDatabaseService, l as MutationCallback, lt as BridgeTokenMessage, m as PinoTransmit, mt as PushPayload, n as DebounceOptions, nt as WebPushSyncOptions, o as Level, ot as WebPushUpdateOptions, p as PhaseStat, pt as PushOp, q as WebPushDevice, r as EdgeDelta, rt as WebPushSyncStatus, s as MATERIALIZATION_SAMPLE_WINDOW, st as detectWebPushSupport, t as ConnectionState, tt as WebPushSupport, u as MutationEvent, ut as PUSH_PAYLOAD_VERSION, v as QueryConfig, vt as isPushPayload, w as QueryTimeToLive, wt as SignOutHook, x as QueryState, xt as ImpersonationCandidate, y as QueryConfigRecord, yt as ActiveImpersonation, z as SyncHealth, zt as ImpersonationTimers } from "./types.js";
 import { BackendNames, BackendRoutes, BucketNames, FinalQuery, GetTable, QueryBuilder, QueryOptions, QueryPlan, RecordId, RoutePayload, SchemaStructure, TableModel, TableNames } from "@spooky-sync/query-builder";
 import * as surrealdb0 from "surrealdb";
 import { Duration, RecordId as RecordId$1, Surreal } from "surrealdb";
@@ -608,7 +608,10 @@ declare class CrdtManager {
   private schema;
   private local;
   private remote;
+  /** First edit after a quiet spell: wait this long to batch the burst. */
   private debounceMs;
+  /** Shortest gap between two sends of one field, while edits keep coming. */
+  private sendIntervalMs;
   private sessions;
   private opening;
   /** Closes still saving their field's local state, by session key. */
@@ -620,7 +623,9 @@ declare class CrdtManager {
   private claim;
   private claimRetry;
   private connectionUnsubscribes;
-  constructor(schema: SchemaStructure, local: LocalStore, remote: RemoteDatabaseService, logger: Logger$1, debounceMs?: number);
+  constructor(schema: SchemaStructure, local: LocalStore, remote: RemoteDatabaseService, logger: Logger$1, /** First edit after a quiet spell: wait this long to batch the burst. */
+  debounceMs?: number, /** Shortest gap between two sends of one field, while edits keep coming. */
+  sendIntervalMs?: number);
   /** Hand over the runtime ports. Called once by the client facade. */
   attach(ports: CrdtPorts): void;
   /**
@@ -680,7 +685,16 @@ declare class CrdtManager {
    * be merged away; that is logged.
    */
   private verify;
+  /**
+   * 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).
+   */
   private scheduleFlush;
+  /** 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. */
   private flush;
   /** Send every own peer's ops that are not in the outbox yet, one row per
    *  peer. Only the peer's own ops travel (`updates-in-range`): a plain
@@ -961,6 +975,7 @@ type RuntimeEvent = {
   type: 'LiveChange';
   hashes: QueryHash[];
   rows?: InlineRow[];
+  deltas?: EdgeDelta[];
 } | {
   type: 'TabRole';
   role: 'solo' | 'leader' | 'follower';
@@ -1442,7 +1457,7 @@ interface Adapters {
      * changed query hashes, plus the changed rows themselves when the
      * subscription was opened with the body joined on (`liveInlineBodies`).
      */
-    live(table: string, onChange: (hashes: string[], rows?: InlineRow[]) => void): Promise<string>;
+    live(table: string, onChange: (hashes: string[], rows?: InlineRow[], deltas?: EdgeDelta[]) => void): Promise<string>;
     kill(uuid: string): Promise<void>;
   };
   ssp: {
@@ -2197,4 +2212,4 @@ declare class LocalOpTimeoutError extends Error {
  *  select on a throttled tab is seconds, not tens of seconds. */
 declare const DEFAULT_LOCAL_OP_TIMEOUT_MS = 30000;
 //#endregion
-export { ActiveImpersonation, AppReleaseHandle, AppReleaseModule, type AppReleaseOptions, type AppReleaseSnapshot, AuthEventSystem, AuthEventTypeMap, AuthEventTypes, AuthService, BLURHASH_IMAGE_EXTENSIONS, type BlobCacheStats, type BlobEntry, type BlobKey, type BlobReadOptions, type BlobUrlLease, type BlurhashEncodeOptions, type BlurhashSetting, type BridgeSignOutMessage, type BridgeTokenMessage, BucketHandle, BucketPutOptions, BucketPutResult, CURSOR_COLORS, ConnectionState, CrdtField, CrdtManager, DEFAULT_LOCAL_OP_TIMEOUT_MS, DebounceOptions, EventSubscriptionOptions, type FailedMutationRow as FailedMutation, FeatureFlagHandle, FeatureFlagModule, type FeatureFlagOptions, type FeatureFlagOverride, type FeatureFlagSnapshot, IMPERSONATION_ACCESS, ImpersonationCandidate, ImpersonationInfo, ImpersonationTimerHost, ImpersonationTimers, InlineRow, Level, LocalOpTimeoutError, MATERIALIZATION_SAMPLE_WINDOW, MembershipOutcome, MutationCallback, MutationEvent, MutationEventType, ORIGIN_TOKEN_KEY, PUSH_ENDPOINT_KEY, PUSH_PAYLOAD_VERSION, PersistenceClient, PhaseStat, PinoTransmit, PreloadOptions, PreloadRefresh, type PushDeviceKind, type PushNotification, type PushNotificationAction, type PushOp, type PushPayload, type PushPayloadKind, type PushUrgency, QueryAuthorityCallback, QueryConfig, QueryConfigRecord, QueryHash, QueryState, QueryStatus, QueryStatusCallback, QueryTimeToLive, QueryTimings, QueryUpdateCallback, ReconnectConfig, RecordVersionArray, RecordVersionDiff, RegistrationTimings, RunOptions, SESSION_POLL_MS, SIGN_OUT_HOOK_TIMEOUT_MS, ServerViewMeta, SignOutContext, SignOutHook, Sp00kyClient, Sp00kyClientDeps, Sp00kyConfig, Sp00kyQueryResult, Sp00kyQueryResultPromise, StorageHealth, StorageHealthStatus, StoreType, SyncHealth, SyncHealthConfig, SyncHealthStatus, TimingPhase, TokenClaims, UpdateOptions, type WebPushClientMessage, type WebPushConfig, type WebPushDevice, WebPushError, type WebPushErrorCode, type WebPushInfo, type WebPushMessage, type WebPushMessageInput, WebPushModule, type WebPushSubscribeOptions, type WebPushSupport, type WebPushSyncOptions, type WebPushSyncStatus, type WebPushUnsubscribeOptions, type WebPushUnsupportedReason, type WebPushUpdateOptions, blurhashSidecarPath, bucketContentToBlob, createAuthEventSystem, cursorColorFromName, decode as decodeBlurhash, decodeTokenClaims, detectWebPushSupport, encode as encodeBlurhash, encodeImageToBlurhash, fileToUint8Array, impersonationFromToken, isBlurhashValid, isImagePath, isPushPayload, renewDelayMs, sameImpersonation, semverGt, textToHtml };
+export { ActiveImpersonation, AppReleaseHandle, AppReleaseModule, type AppReleaseOptions, type AppReleaseSnapshot, AuthEventSystem, AuthEventTypeMap, AuthEventTypes, AuthService, BLURHASH_IMAGE_EXTENSIONS, type BlobCacheStats, type BlobEntry, type BlobKey, type BlobReadOptions, type BlobUrlLease, type BlurhashEncodeOptions, type BlurhashSetting, type BridgeSignOutMessage, type BridgeTokenMessage, BucketHandle, BucketPutOptions, BucketPutResult, CURSOR_COLORS, ConnectionState, CrdtField, CrdtManager, DEFAULT_LOCAL_OP_TIMEOUT_MS, DebounceOptions, EdgeDelta, EventSubscriptionOptions, type FailedMutationRow as FailedMutation, FeatureFlagHandle, FeatureFlagModule, type FeatureFlagOptions, type FeatureFlagOverride, type FeatureFlagSnapshot, IMPERSONATION_ACCESS, ImpersonationCandidate, ImpersonationInfo, ImpersonationTimerHost, ImpersonationTimers, InlineRow, Level, LocalOpTimeoutError, MATERIALIZATION_SAMPLE_WINDOW, MembershipOutcome, MutationCallback, MutationEvent, MutationEventType, ORIGIN_TOKEN_KEY, PUSH_ENDPOINT_KEY, PUSH_PAYLOAD_VERSION, PersistenceClient, PhaseStat, PinoTransmit, PreloadOptions, PreloadRefresh, type PushDeviceKind, type PushNotification, type PushNotificationAction, type PushOp, type PushPayload, type PushPayloadKind, type PushUrgency, QueryAuthorityCallback, QueryConfig, QueryConfigRecord, QueryHash, QueryState, QueryStatus, QueryStatusCallback, QueryTimeToLive, QueryTimings, QueryUpdateCallback, ReconnectConfig, RecordVersionArray, RecordVersionDiff, RegistrationTimings, RunOptions, SESSION_POLL_MS, SIGN_OUT_HOOK_TIMEOUT_MS, ServerViewMeta, SignOutContext, SignOutHook, Sp00kyClient, Sp00kyClientDeps, Sp00kyConfig, Sp00kyQueryResult, Sp00kyQueryResultPromise, StorageHealth, StorageHealthStatus, StoreType, SyncHealth, SyncHealthConfig, SyncHealthStatus, TimingPhase, TokenClaims, UpdateOptions, type WebPushClientMessage, type WebPushConfig, type WebPushDevice, WebPushError, type WebPushErrorCode, type WebPushInfo, type WebPushMessage, type WebPushMessageInput, WebPushModule, type WebPushSubscribeOptions, type WebPushSupport, type WebPushSyncOptions, type WebPushSyncStatus, type WebPushUnsubscribeOptions, type WebPushUnsupportedReason, type WebPushUpdateOptions, blurhashSidecarPath, bucketContentToBlob, createAuthEventSystem, cursorColorFromName, decode as decodeBlurhash, decodeTokenClaims, detectWebPushSupport, encode as encodeBlurhash, encodeImageToBlurhash, fileToUint8Array, impersonationFromToken, isBlurhashValid, isImagePath, isPushPayload, renewDelayMs, sameImpersonation, semverGt, textToHtml };

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.331";
-const WASM_VERSION = "0.0.1-canary.331";
+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 {
@@ -12625,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;
@@ -12648,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()) {
@@ -12773,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,
@@ -12788,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);
@@ -12988,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;
 		});
@@ -13017,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;
@@ -13051,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);
@@ -15084,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
@@ -15541,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 {
@@ -15567,7 +15676,7 @@ function createTabsCoordinator(config, s, host) {
 	return new TabsCoordinator({
 		tabId: s.tabId,
 		fingerprint: computeTabsFingerprint({
-			coreVersion: "0.0.1-canary.331",
+			coreVersion: "0.0.1-canary.332",
 			schemaHash: hash53(config.schemaSurql),
 			endpoint: config.database.endpoint ?? "",
 			namespace: config.database.namespace,
@@ -15787,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);
 			},

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
 /**

package/dist/types.d.ts

@@ -1594,14 +1594,20 @@ interface Sp00kyConfig<S extends SchemaStructure> {
    */
   streamDebounceTime?: number;
   /**
-   * Debounce time in milliseconds for syncing collaborative (CRDT) field
-   * edits to the server. Local state is kept on every change (so reload and
-   * offline work), but a field's own new ops go out as one edit-log row per
-   * pause of this length (at most 2 s apart while typing continues).
-   * Lower = snappier propagation and more rows; higher = fewer rows and more
-   * lag for other collaborators. Defaults to 300ms.
+   * How long in milliseconds the first edit to a collaborative (CRDT) field
+   * after a quiet spell waits before it goes out, so a burst of keystrokes
+   * travels as one edit-log row. Local state is kept on every change (so
+   * reload and offline work). Defaults to 50ms.
    */
   crdtDebounceMs?: number;
+  /**
+   * The shortest gap in milliseconds between two edit-log rows of one CRDT
+   * field: while someone keeps typing, their edits go out on this cadence
+   * instead of waiting for a pause. Lower = other collaborators see the text
+   * sooner and more rows are written; higher = fewer rows and more lag.
+   * Defaults to 200ms.
+   */
+  crdtSendIntervalMs?: number;
   /**
    * Enable collaborative CRDT fields. When `true`, the `loro-crdt` engine is
    * preloaded at client startup (fetched as a separate chunk on page load) so
@@ -1635,15 +1641,16 @@ interface Sp00kyConfig<S extends SchemaStructure> {
    * back for it.
    *
    * The client holds exactly one live subscription, on its `_00_list_ref`
-   * table, and today it is a doorbell: the notification is reduced to the
-   * query hash and the row is then pulled with `SELECT * FROM $ids`. The edge
+   * table. Without this, the notification names the row and the client then
+   * pulls it with `SELECT * FROM $ids`. The edge
    * is a real graph edge, so `FETCH out` makes SurrealDB resolve the row into
    * the notification and the body fetch disappears.
    *
    * The push stays advisory: the body is landed exactly the way a fetched body
    * is (store write, circuit ingest, version recorded), so a notification the
-   * server drops costs nothing but the old round trip. Membership is still
-   * read back; only the body fetch is saved.
+   * server drops costs nothing but the old round trip. A row joining a live
+   * view is committed to membership from the notification either way (no
+   * re-read); with this on, the body fetch is saved as well.
    *
    * Default `false`. The cost is wire bytes: one edit bumps the edge in every
    * view holding the row, and under `FETCH` each of those notifications
@@ -1873,6 +1880,17 @@ 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`).
+ */
+interface EdgeDelta {
+  hash: QueryHash;
+  id: string;
+  version: number;
+}
 type RecordVersionArray = Array<[string, number]>;
 /**
  * Represents the difference between two record version sets.
@@ -2175,4 +2193,4 @@ interface DebounceOptions {
   flushOnHide?: boolean;
 }
 //#endregion
-export { WebPushSubscribeOptions as $, RunOptions as A, Logger$1 as At, SyncHealthStatus as B, SESSION_POLL_MS as Bt, QueryTimeToLive as C, SignOutHook as Ct, RecordVersionArray as D, createAuthEventSystem as Dt, ReconnectConfig as E, AuthEventTypes as Et, StorageHealth as F, IMPERSONATION_ACCESS as Ft, WebPushConfig as G, sameImpersonation as Gt, UpdateOptions as H, decodeTokenClaims as Ht, StorageHealthStatus as I, ImpersonationInfo as It, WebPushErrorCode as J, WebPushDevice as K, StoreType as L, ImpersonationTimerHost as Lt, Sp00kyConfig as M, SealedQuery as Mt, Sp00kyQueryResult as N, EventDefinition as Nt, RecordVersionDiff as O, RemoteDatabaseService as Ot, Sp00kyQueryResultPromise as P, EventSystem as Pt, WebPushModule as Q, SyncHealth as R, ImpersonationTimers as Rt, QueryStatusCallback as S, SignOutContext as St, QueryUpdateCallback as T, AuthEventTypeMap as Tt, PUSH_ENDPOINT_KEY as U, impersonationFromToken as Ut, TimingPhase as V, TokenClaims as Vt, PushDeviceKind as W, renewDelayMs as Wt, WebPushMessage as X, WebPushInfo as Y, WebPushMessageInput as Z, QueryConfig as _, isPushPayload as _t, Level$1 as a, WebPushUpdateOptions as at, QueryState as b, ImpersonationCandidate as bt, MutationCallback as c, BridgeTokenMessage as ct, PersistenceClient as d, PushNotificationAction as dt, WebPushSupport as et, PhaseStat as f, PushOp as ft, QueryAuthorityCallback as g, WebPushClientMessage as gt, PreloadRefresh as h, PushUrgency as ht, InlineRow as i, WebPushUnsupportedReason as it, ServerViewMeta as j, LocalStore as jt, RegistrationTimings as k, LogTap as kt, MutationEvent as l, PUSH_PAYLOAD_VERSION as lt, PreloadOptions as m, PushPayloadKind as mt, DebounceOptions as n, WebPushSyncStatus as nt, MATERIALIZATION_SAMPLE_WINDOW as o, detectWebPushSupport as ot, PinoTransmit as p, PushPayload as pt, WebPushError as q, EventSubscriptionOptions as r, WebPushUnsubscribeOptions as rt, MembershipOutcome as s, BridgeSignOutMessage as st, ConnectionState as t, WebPushSyncOptions as tt, MutationEventType as u, PushNotification as ut, QueryConfigRecord as v, ActiveImpersonation as vt, QueryTimings as w, AuthEventSystem as wt, QueryStatus as x, SIGN_OUT_HOOK_TIMEOUT_MS as xt, QueryHash as y, AuthService as yt, SyncHealthConfig as z, ORIGIN_TOKEN_KEY as zt };
+export { WebPushModule as $, RegistrationTimings as A, LogTap as At, SyncHealthConfig as B, ORIGIN_TOKEN_KEY as Bt, QueryStatusCallback as C, SignOutContext as Ct, ReconnectConfig as D, AuthEventTypes as Dt, QueryUpdateCallback as E, AuthEventTypeMap as Et, Sp00kyQueryResultPromise as F, EventSystem as Ft, PushDeviceKind as G, renewDelayMs as Gt, TimingPhase as H, TokenClaims as Ht, StorageHealth as I, IMPERSONATION_ACCESS as It, WebPushError as J, WebPushConfig as K, sameImpersonation as Kt, StorageHealthStatus as L, ImpersonationInfo as Lt, ServerViewMeta as M, LocalStore as Mt, Sp00kyConfig as N, SealedQuery as Nt, RecordVersionArray as O, createAuthEventSystem as Ot, Sp00kyQueryResult as P, EventDefinition as Pt, WebPushMessageInput as Q, StoreType as R, ImpersonationTimerHost as Rt, QueryStatus as S, SIGN_OUT_HOOK_TIMEOUT_MS as St, QueryTimings as T, AuthEventSystem as Tt, UpdateOptions as U, decodeTokenClaims as Ut, SyncHealthStatus as V, SESSION_POLL_MS as Vt, PUSH_ENDPOINT_KEY as W, impersonationFromToken as Wt, WebPushInfo as X, WebPushErrorCode as Y, WebPushMessage as Z, QueryAuthorityCallback as _, WebPushClientMessage as _t, InlineRow as a, WebPushUnsupportedReason as at, QueryHash as b, AuthService as bt, MembershipOutcome as c, BridgeSignOutMessage as ct, MutationEventType as d, PushNotification as dt, WebPushSubscribeOptions as et, PersistenceClient as f, PushNotificationAction as ft, PreloadRefresh as g, PushUrgency as gt, PreloadOptions as h, PushPayloadKind as ht, EventSubscriptionOptions as i, WebPushUnsubscribeOptions as it, RunOptions as j, Logger$1 as jt, RecordVersionDiff as k, RemoteDatabaseService as kt, MutationCallback as l, BridgeTokenMessage as lt, PinoTransmit as m, PushPayload as mt, DebounceOptions as n, WebPushSyncOptions as nt, Level$1 as o, WebPushUpdateOptions as ot, PhaseStat as p, PushOp as pt, WebPushDevice as q, EdgeDelta as r, WebPushSyncStatus as rt, MATERIALIZATION_SAMPLE_WINDOW as s, detectWebPushSupport as st, ConnectionState as t, WebPushSupport as tt, MutationEvent as u, PUSH_PAYLOAD_VERSION as ut, QueryConfig as v, isPushPayload as vt, QueryTimeToLive as w, SignOutHook as wt, QueryState as x, ImpersonationCandidate as xt, QueryConfigRecord as y, ActiveImpersonation as yt, SyncHealth as z, ImpersonationTimers as zt };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spooky-sync/core",
-  "version": "0.0.1-canary.331",
+  "version": "0.0.1-canary.332",
   "type": "module",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -75,8 +75,8 @@
     }
   },
   "dependencies": {
-    "@spooky-sync/query-builder": "0.0.1-canary.331",
-    "@spooky-sync/ssp-wasm": "0.0.1-canary.331",
+    "@spooky-sync/query-builder": "0.0.1-canary.332",
+    "@spooky-sync/ssp-wasm": "0.0.1-canary.332",
     "@sqlite.org/sqlite-wasm": "3.53.0-build1",
     "@surrealdb/wasm": "^3.1.0",
     "@surrealdb/wasm-native": "^3.3.4",

package/src/client/router.ts

@@ -77,7 +77,7 @@ export function route(env: SagaEnv, event: RuntimeEvent): RouteTarget {
     case 'LiveStart':
       return { saga: liveStart(env), lane: serial('live') };
     case 'LiveChange':
-      return { saga: liveChange(env, event.hashes, event.rows), lane: serial('live-change') };
+      return { saga: liveChange(env, event.hashes, event.rows, event.deltas), lane: serial('live-change') };
     case 'TabRole':
       return { saga: setRole(env, event.role), lane: serial('tabs') };
     case 'TabMessage':

package/src/client/services.ts

@@ -30,7 +30,7 @@ import type { ServiceCalls } from '../kernel/effects';
 import { encodeRecordId, mintOwnerSecret } from '../utils/index';
 import { sha256Hex } from '../utils/sha256';
 import { leaveViewsBeacon, listRefLive } from '../query/sql';
-import { hashOfEdge, rowOfEdge } from '../utils/edges';
+import { deltaOfEdge, hashOfEdge, rowOfEdge } from '../utils/edges';
 import { mintMutationId } from '../mutation/mutation-id';
 import { BucketHandle, bucketContentToBlob, bucketSettings } from './bucket-handle';
 
@@ -176,7 +176,7 @@ export function createServices<S extends SchemaStructure>(config: Sp00kyConfig<S
   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 {
@@ -395,7 +395,8 @@ export function createAdapters<S extends SchemaStructure>(config: Sp00kyConfig<S
           // that was actually deleted the join yields nothing anyway. Landing
           // a body there would only ever write back what is going away.
           const row = message.action === 'DELETE' ? null : rowOfEdge(message.value);
-          onChange([hash], row ? [row] : undefined);
+          const delta = deltaOfEdge(message.action, message.value);
+          onChange([hash], row ? [row] : undefined, delta ? [delta] : undefined);
         });
         return String(uuid);
       },