@spooky-sync/core 0.0.1-canary.161 → 0.0.1-canary.162

package/dist/otel/index.d.ts

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

package/dist/types.d.ts

@@ -457,6 +457,22 @@ interface Sp00kyConfig<S extends SchemaStructure> {
      * multi-hop path (escape hatch while the worker-side path beds in).
      */
     workerSelect?: boolean;
+    /**
+     * WebSocket reconnect + liveness tuning. All fields optional; the defaults
+     * keep the connection alive indefinitely without configuration. See
+     * {@link ReconnectConfig}.
+     */
+    reconnect?: ReconnectConfig;
+    /**
+     * Deadline (ms) for every remote RPC. Remote queries are serialized through
+     * a single promise chain, so one call that never settles (half-open socket:
+     * the WebSocket looks open, the peer is gone, no `close` event fires) would
+     * otherwise wedge ALL later remote traffic behind it — including the sync
+     * poll's own health probe, leaving health pinned at `healthy` with no
+     * banner and no self-heal. The deadline turns that into an ordinary network
+     * failure the queue retries. `0` disables. Defaults to `60_000`.
+     */
+    queryTimeoutMs?: number;
   };
   /** The schema definition. */
   schema: S;
@@ -587,6 +603,15 @@ interface Sp00kyConfig<S extends SchemaStructure> {
    * (or `degradeAfterConsecutiveFailures: 0`) to never report degraded.
    */
   syncHealth?: SyncHealthConfig | false;
+  /**
+   * Deadline (ms) for a single outgoing mutation push. Tighter than
+   * {@link Sp00kyConfig.database.queryTimeoutMs} because the up-queue drains
+   * one mutation at a time behind an `isSyncingUp` flag: a push that never
+   * settles stops every later mutation for the session, with no retry and no
+   * error. On expiry the push is treated as a network failure and re-queued.
+   * `0` disables. Defaults to `30_000`.
+   */
+  pushTimeoutMs?: number;
 }
 /** Tunables for sync-health reporting. See {@link Sp00kyConfig.syncHealth}. */
 interface SyncHealthConfig {
@@ -598,6 +623,53 @@ interface SyncHealthConfig {
    */
   degradeAfterConsecutiveFailures?: number;
 }
+/**
+ * Tunables for WebSocket reconnect and liveness detection. See
+ * {@link Sp00kyConfig.database.reconnect}.
+ *
+ * Two independent mechanisms cooperate here. The SurrealDB SDK reconnects on
+ * its own after a socket `close` (`attempts` / `retryDelayMax`), and a
+ * supervisor above it re-opens the connection from scratch whenever the SDK
+ * gives up or its post-reconnect handshake fails — the SDK terminates the
+ * engine permanently in that case, so a supervisor is required, not optional.
+ * The heartbeat covers the third case: a socket that never closes at all.
+ */
+interface ReconnectConfig {
+  /**
+   * SDK reconnect attempts after a socket close. `-1` retries forever.
+   * Defaults to `-1` (the SDK's own default is `5`, which caps recovery at a
+   * ~62s outage and then gives up for the life of the page).
+   */
+  attempts?: number;
+  /** Cap on the SDK's exponential backoff delay. Defaults to `15_000`. */
+  retryDelayMax?: number;
+  /**
+   * Cadence of the application-level liveness probe (`RETURN true`) that
+   * detects a half-open socket the transport never reports as closed.
+   * `0` disables the heartbeat. Defaults to `20_000`.
+   */
+  heartbeatIntervalMs?: number;
+  /**
+   * Deadline for a heartbeat response. Exceeding it means the socket is dead
+   * regardless of what its `readyState` claims, so the connection is torn down
+   * and rebuilt. Defaults to `10_000`.
+   */
+  heartbeatTimeoutMs?: number;
+  /**
+   * Cap on the supervisor's own backoff between `connect()` retries once the
+   * SDK has given up. Defaults to `15_000`.
+   */
+  superviseRetryDelayMaxMs?: number;
+}
+/**
+ * Transport-level connection state, independent of {@link SyncHealthStatus}.
+ *
+ * These answer different questions: `connection` is about the socket,
+ * `status` is about whether sync rounds are succeeding. A `connected` socket
+ * can still be `degraded` (server erroring), and a `reconnecting` socket is
+ * usually still `healthy` for the first few seconds.
+ */
+type ConnectionState = 'connecting' | 'connected' | 'reconnecting' | 'disconnected';
 type SyncHealthStatus = 'healthy' | 'degraded';
 /** Snapshot of sync health delivered to `subscribeToSyncHealth` subscribers. */
 interface SyncHealth {
@@ -616,6 +688,13 @@ interface SyncHealth {
    * a working session. Never resets back to `false` once set.
    */
   everConnected: boolean;
+  /**
+   * Live transport state of the remote WebSocket. Distinct from `status`: this
+   * one flips the instant the socket drops, whereas `status` only degrades
+   * after a sustained run of failed sync rounds. Use it to show "reconnecting…"
+   * immediately without waiting for the degrade threshold.
+   */
+  connection: ConnectionState;
 }
 type StorageHealthStatus = 'unknown' | 'persistent' | 'memory';
 /**
@@ -699,6 +778,24 @@ interface QueryConfig {
    * `rowCount` / `localArray`.
    */
   subqueryRemoteArray?: RecordVersionArray;
+  /**
+   * Whether authoritative membership (`remoteArray`) has ever been established
+   * for this query — either fetched from `_00_list_ref` this session, or read
+   * back from the durable `_00_window` row on a cold start.
+   *
+   * Tri-state matters: "known and empty" must render an empty list, while
+   * "never established" has to fall back to a predicate scan of the local store
+   * so a query first run on this device still paints offline. A
+   * `remoteArray.length === 0` check cannot tell those apart.
+   */
+  membershipKnown?: boolean;
+  /**
+   * Key of this query's durable `_00_window` membership row: a hash of
+   * `{surql, params}` WITHOUT the `session::id()` salt that `id` carries, so it
+   * survives a reload (which mints a new session id) and a bucket switch.
+   * In-memory only.
+   */
+  membershipKey?: string;
   /** Time-To-Live for this query. */
   ttl: QueryTimeToLive;
   /** Timestamp when the query was last accessed/active. */
@@ -871,4 +968,4 @@ interface DebounceOptions {
   delay?: number;
 }
 //#endregion
-export { StorageHealthStatus as A, DatabaseEventSystem as B, RecordVersionDiff as C, Sp00kyQueryResult as D, Sp00kyConfig as E, TimingPhase as F, EventSystem as G, Logger$1 as H, UpdateOptions as I, UpEvent as L, SyncHealth as M, SyncHealthConfig as N, Sp00kyQueryResultPromise as O, SyncHealthStatus as P, LocalStore as R, RecordVersionArray as S, RunOptions as T, SyncEventSystem as U, DatabaseEventTypes as V, EventDefinition as W, QueryStatus as _, MutationCallback as a, QueryTimings as b, PersistenceClient as c, PreloadOptions as d, PreloadRefresh as f, QueryState as g, QueryHash as h, MATERIALIZATION_SAMPLE_WINDOW as i, StoreType as j, StorageHealth as k, PhaseStat as l, QueryConfigRecord as m, EventSubscriptionOptions as n, MutationEvent as o, QueryConfig as p, Level$1 as r, MutationEventType as s, DebounceOptions as t, PinoTransmit as u, QueryStatusCallback as v, RegistrationTimings as w, QueryUpdateCallback as x, QueryTimeToLive as y, SealedQuery as z };
+export { Sp00kyQueryResultPromise as A, LocalStore as B, ReconnectConfig as C, RunOptions as D, RegistrationTimings as E, SyncHealthConfig as F, SyncEventSystem as G, DatabaseEventSystem as H, SyncHealthStatus as I, EventDefinition as K, TimingPhase as L, StorageHealthStatus as M, StoreType as N, Sp00kyConfig as O, SyncHealth as P, UpdateOptions as R, QueryUpdateCallback as S, RecordVersionDiff as T, DatabaseEventTypes as U, SealedQuery as V, Logger$1 as W, QueryState as _, MATERIALIZATION_SAMPLE_WINDOW as a, QueryTimeToLive as b, MutationEventType as c, PinoTransmit as d, PreloadOptions as f, QueryHash as g, QueryConfigRecord as h, Level$1 as i, StorageHealth as j, Sp00kyQueryResult as k, PersistenceClient as l, QueryConfig as m, DebounceOptions as n, MutationCallback as o, PreloadRefresh as p, EventSystem as q, EventSubscriptionOptions as r, MutationEvent as s, ConnectionState as t, PhaseStat as u, QueryStatus as v, RecordVersionArray as w, QueryTimings as x, QueryStatusCallback as y, UpEvent as z };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spooky-sync/core",
-  "version": "0.0.1-canary.161",
+  "version": "0.0.1-canary.162",
   "type": "module",
   "sideEffects": false,
   "main": "./dist/index.js",
@@ -60,8 +60,8 @@
     }
   },
   "dependencies": {
-    "@spooky-sync/query-builder": "0.0.1-canary.161",
-    "@spooky-sync/ssp-wasm": "0.0.1-canary.161",
+    "@spooky-sync/query-builder": "0.0.1-canary.162",
+    "@spooky-sync/ssp-wasm": "0.0.1-canary.162",
     "@sqlite.org/sqlite-wasm": "3.53.0-build1",
     "@surrealdb/wasm": "^3.0.3",
     "fast-json-patch": "^3.1.1",

package/src/modules/crdt/crdt-hydration.test.ts

@@ -76,6 +76,10 @@ function makeRemote(handlers: {
           subscribe: () => () => {},
         }),
       }) as any,
+    // CrdtManager watches transport events so it can re-issue table LIVEs after
+    // a reconnect. These tests never drop the socket, so a no-op is enough.
+    getStatus: () => 'connected' as const,
+    subscribeConnection: vi.fn().mockReturnValue(() => {}),
   } satisfies Partial<RemoteDatabaseService> as unknown as RemoteDatabaseService;
   return remote;
 }

package/src/modules/crdt/crdt-reconnect.test.ts

@@ -0,0 +1,195 @@
+import { describe, it, expect, vi } from 'vitest';
+import type { SchemaStructure } from '@spooky-sync/query-builder';
+import { CrdtManager } from './index';
+import type { LocalStore, RemoteDatabaseService } from '../../services/database/index';
+import type { Logger } from '../../services/logger/index';
+
+// A LIVE subscription lives and dies with its WebSocket session, and
+// `ensureTableSubscription` is memoized on `liveByTable`. Without a reconnect
+// hook, the first dropped socket kills CRDT realtime for good: the map still
+// holds a uuid for a subscription the server has forgotten, so every later
+// `open()` short-circuits and no LIVE is ever re-issued.
+
+const noop = () => {};
+
+/** A promise plus its resolver, so a test can hold an RPC open on demand. */
+function deferred<T>(): { promise: Promise<T>; resolve: (v: T) => void } {
+  let resolve!: (v: T) => void;
+  const promise = new Promise<T>((r) => {
+    resolve = r;
+  });
+  return { promise, resolve };
+}
+
+function silentLogger(): Logger {
+  const fake: any = {};
+  fake.info = noop;
+  fake.warn = noop;
+  fake.debug = noop;
+  fake.error = noop;
+  fake.trace = noop;
+  fake.child = () => fake;
+  return fake as Logger;
+}
+
+function singleTableSchema(): SchemaStructure {
+  return {
+    tables: [
+      {
+        name: 'thread',
+        columns: { body: { type: 'string', optional: false, crdt: 'text' } },
+        primaryKey: ['id'],
+      },
+    ],
+    relationships: [],
+    backends: {},
+  };
+}
+
+function makeRemote() {
+  const handlers = new Map<string, Array<(...a: any[]) => void>>();
+  const remote = {
+    query: vi.fn().mockImplementation(async (sql: string) => {
+      if (sql.includes('LIVE SELECT')) return ['live-uuid'];
+      if (sql.includes('SELECT * FROM ONLY')) return [null];
+      return [];
+    }),
+    getClient: () =>
+      ({ liveOf: async () => ({ subscribe: () => () => {} }) }) as any,
+    getStatus: () => 'connected' as const,
+    subscribeConnection: (event: string, cb: (...a: any[]) => void) => {
+      handlers.set(event, [...(handlers.get(event) ?? []), cb]);
+      return () => {
+        handlers.set(event, (handlers.get(event) ?? []).filter((h) => h !== cb));
+      };
+    },
+  } satisfies Partial<RemoteDatabaseService> as unknown as RemoteDatabaseService;
+  const emit = (event: string) => {
+    for (const cb of Array.from(handlers.get(event) ?? [])) cb();
+  };
+  return { remote, emit };
+}
+
+function makeLocal(): LocalStore {
+  return {
+    query: vi.fn().mockResolvedValue([null]),
+  } satisfies Partial<LocalStore> as unknown as LocalStore;
+}
+
+const liveSelects = (remote: RemoteDatabaseService) =>
+  (remote.query as ReturnType<typeof vi.fn>).mock.calls
+    .map((c) => c[0] as string)
+    .filter((s) => s.includes('LIVE SELECT'));
+
+describe('CrdtManager reconnect', () => {
+  it('re-issues the table LIVE after a recovered drop', async () => {
+    const { remote, emit } = makeRemote();
+    const manager = new CrdtManager(singleTableSchema(), makeLocal(), remote, silentLogger());
+    manager.setSessionId('s1');
+
+    await manager.open('thread', 'thread:abc', 'body');
+    await vi.waitFor(() => expect(liveSelects(remote)).toHaveLength(1));
+
+    // The SDK's own reconnect path: `reconnecting` then `connected`, never
+    // `disconnected`.
+    emit('reconnecting');
+    emit('connected');
+
+    await vi.waitFor(() => expect(liveSelects(remote)).toHaveLength(2));
+    // No KILL: that uuid belonged to a session that no longer exists.
+    const sqls = (remote.query as ReturnType<typeof vi.fn>).mock.calls.map((c) => c[0] as string);
+    expect(sqls.some((s) => s.includes('KILL'))).toBe(false);
+  });
+
+  it('re-issues the table LIVE after the SDK gives up', async () => {
+    const { remote, emit } = makeRemote();
+    const manager = new CrdtManager(singleTableSchema(), makeLocal(), remote, silentLogger());
+    manager.setSessionId('s1');
+
+    await manager.open('thread', 'thread:abc', 'body');
+    await vi.waitFor(() => expect(liveSelects(remote)).toHaveLength(1));
+
+    emit('disconnected');
+    emit('connected');
+
+    await vi.waitFor(() => expect(liveSelects(remote)).toHaveLength(2));
+  });
+
+  it('does not resurrect a LIVE for a table whose fields were all closed', async () => {
+    const { remote, emit } = makeRemote();
+    const manager = new CrdtManager(singleTableSchema(), makeLocal(), remote, silentLogger());
+    manager.setSessionId('s1');
+
+    await manager.open('thread', 'thread:abc', 'body');
+    await vi.waitFor(() => expect(liveSelects(remote)).toHaveLength(1));
+
+    // A drop can outlive the editor that needed the feed.
+    emit('reconnecting');
+    manager.close('thread', 'thread:abc', 'body');
+    emit('connected');
+
+    await new Promise((r) => setTimeout(r, 10));
+    expect(liveSelects(remote)).toHaveLength(1);
+  });
+
+  it('discards and re-registers a LIVE that was mid-flight when the socket dropped', async () => {
+    const handlers = new Map<string, Array<() => void>>();
+    const firstLive = deferred<void>();
+    let liveCalls = 0;
+    const remote = {
+      query: vi.fn().mockImplementation(async (sql: string) => {
+        if (sql.includes('LIVE SELECT')) {
+          liveCalls++;
+          // Hold the FIRST registration open so the drop lands mid-flight.
+          if (liveCalls === 1) {
+            await firstLive.promise;
+            return ['dead-session-uuid'];
+          }
+          return ['fresh-uuid'];
+        }
+        return [null];
+      }),
+      getClient: () => ({ liveOf: async () => ({ subscribe: () => () => {} }) }) as any,
+      getStatus: () => 'connected' as const,
+      subscribeConnection: (event: string, cb: () => void) => {
+        handlers.set(event, [...(handlers.get(event) ?? []), cb]);
+        return () => {};
+      },
+    } satisfies Partial<RemoteDatabaseService> as unknown as RemoteDatabaseService;
+    const emit = (event: string) => {
+      for (const cb of Array.from(handlers.get(event) ?? [])) cb();
+    };
+
+    const manager = new CrdtManager(singleTableSchema(), makeLocal(), remote, silentLogger());
+    manager.setSessionId('s1');
+    await manager.open('thread', 'thread:abc', 'body');
+    await vi.waitFor(() => expect(liveCalls).toBe(1));
+
+    // Drop + recover while the first registration is still awaiting its uuid.
+    emit('reconnecting');
+    emit('connected');
+    firstLive.resolve();
+
+    // The doomed uuid must never be recorded — if it were, `liveByTable` would
+    // short-circuit every future restart and CRDT realtime would be dead for
+    // good. A fresh registration must take its place.
+    await vi.waitFor(() => expect(liveCalls).toBe(2));
+    expect((manager as any).liveByTable.get('thread')).toBe('fresh-uuid');
+  });
+
+  it('stops reacting to transport events after dispose', async () => {
+    const { remote, emit } = makeRemote();
+    const manager = new CrdtManager(singleTableSchema(), makeLocal(), remote, silentLogger());
+    manager.setSessionId('s1');
+
+    await manager.open('thread', 'thread:abc', 'body');
+    await vi.waitFor(() => expect(liveSelects(remote)).toHaveLength(1));
+
+    manager.dispose();
+    emit('reconnecting');
+    emit('connected');
+
+    await new Promise((r) => setTimeout(r, 10));
+    expect(liveSelects(remote)).toHaveLength(1);
+  });
+});

package/src/modules/crdt/index.ts

@@ -33,8 +33,19 @@ export class CrdtManager {
   private fields = new Map<string, CrdtField>();
   // One LIVE subscription per parent table (e.g. "thread" → uuid).
   private liveByTable = new Map<string, Uuid>();
-  // Coalesces concurrent first-time subscribes for the same table.
-  private pendingLive = new Map<string, Promise<void>>();
+  // Coalesces concurrent first-time subscribes for the same table. Stamped with
+  // the connection generation it started under, so a restart after a drop can
+  // tell a reusable in-flight attempt from a doomed one.
+  private pendingLive = new Map<string, { promise: Promise<void>; generation: number }>();
+  // Tables whose LIVE died with a dropped socket, awaiting the next `connected`
+  // to be re-subscribed. Held separately because `liveByTable` is cleared on the
+  // drop (those uuids belong to a session that no longer exists).
+  private staleTables = new Set<string>();
+  // Bumped on every socket drop. A LIVE registration that started under an
+  // older generation is discarded rather than recorded, so a drop landing
+  // mid-registration can't leave a uuid from a dead session in `liveByTable`.
+  private connectionGeneration = 0;
+  private connectionUnsubscribes: Array<() => void> = [];
   private logger: Logger;
   // SurrealDB session id, used as the per-session key inside `_00_cursor`.
   private sessionId: string = '';
@@ -47,6 +58,66 @@ export class CrdtManager {
     private debounceMs: number = 500,
   ) {
     this.logger = logger.child({ service: 'CrdtManager' });
+    this.subscribeToReconnect();
+  }
+
+  /**
+   * Re-establish table LIVEs after a socket drop.
+   *
+   * A LIVE subscription lives and dies with its WebSocket session, and
+   * `ensureTableSubscription` is memoized on `liveByTable` — so without this,
+   * the first reconnect leaves CRDT realtime permanently dead: the map still
+   * holds a uuid for a subscription the server has forgotten, so every later
+   * `open()` short-circuits and no LIVE is ever re-issued.
+   *
+   * Both drop events matter: the SDK publishes `reconnecting` (not
+   * `disconnected`) when it intends to recover on its own, and `disconnected`
+   * only once it has given up.
+   */
+  private subscribeToReconnect(): void {
+    const onDrop = () => {
+      this.connectionGeneration++;
+      for (const table of this.liveByTable.keys()) this.staleTables.add(table);
+      // In-flight registrations count too: they'd otherwise complete against
+      // the dead session and be silently dropped by the generation guard.
+      for (const table of this.pendingLive.keys()) this.staleTables.add(table);
+      // No KILL: the server-side subscriptions are already gone, and these
+      // uuids would resolve against the new session.
+      this.liveByTable.clear();
+    };
+    this.connectionUnsubscribes.push(
+      this.remote.subscribeConnection('reconnecting', onDrop),
+      this.remote.subscribeConnection('disconnected', onDrop),
+      this.remote.subscribeConnection('connected', () => {
+        const tables = Array.from(this.staleTables);
+        this.staleTables.clear();
+        for (const table of tables) {
+          // Only resurrect tables that still have an open field — a drop can
+          // outlive the editor that needed the feed.
+          if (!this.hasOpenFieldFor(table)) continue;
+          void this.ensureTableSubscription(table);
+        }
+      })
+    );
+  }
+
+  /** Stop observing transport events. Separate from {@link closeAll}, which also
+   *  runs on a bucket switch where the manager keeps being used. */
+  dispose(): void {
+    for (const off of this.connectionUnsubscribes) {
+      try {
+        off();
+      } catch {
+        /* ignore */
+      }
+    }
+    this.connectionUnsubscribes = [];
+    this.staleTables.clear();
+  }
+
+  private hasOpenFieldFor(table: string): boolean {
+    const prefix = `${table}:`;
+    return Array.from(this.fields.keys()).some((k) => k.startsWith(prefix));
   }
 
   /** Set the session id that scopes this client's cursor entries. Must be
@@ -139,10 +210,10 @@ export class CrdtManager {
     }
 
     // If no fields on this table remain open, tear down the table-wide LIVE.
-    const tablePrefix = `${table}:`;
-    const stillOpen = Array.from(this.fields.keys()).some((k) => k.startsWith(tablePrefix));
-    if (!stillOpen) {
+    if (!this.hasOpenFieldFor(table)) {
       this.killTableSubscription(table);
+      // Also drop any pending post-reconnect restart for it.
+      this.staleTables.delete(table);
     }
 
     this.logger.debug(
@@ -164,6 +235,9 @@ export class CrdtManager {
     for (const table of Array.from(this.liveByTable.keys())) {
       this.killTableSubscription(table);
     }
+    // Nothing is open any more, so nothing should be resurrected on the next
+    // reconnect; `open()` will re-subscribe on demand.
+    this.staleTables.clear();
   }
 
   /** Ensure a single `LIVE SELECT * FROM <table>` is running, shared across
@@ -171,8 +245,26 @@ export class CrdtManager {
   private async ensureTableSubscription(table: string): Promise<void> {
     if (this.liveByTable.has(table)) return;
 
+    // Registering a LIVE takes two round-trips, so a socket drop can land
+    // mid-flight. The generation stamp is what keeps that honest: a registration
+    // that started before the drop must never record its uuid, because this
+    // method short-circuits on `liveByTable` and that stale entry (pointing at a
+    // session the server has forgotten) would block every future restart.
+    const generation = this.connectionGeneration;
+
     const pending = this.pendingLive.get(table);
-    if (pending) return pending;
+    if (pending) {
+      if (pending.generation === generation) return pending.promise;
+      // A registration from before the drop is still settling. It will discard
+      // itself; wait it out, then register fresh on the new socket.
+      await pending.promise.catch(() => {});
+      if (this.liveByTable.has(table)) return;
+      if (generation !== this.connectionGeneration) return;
+      // Another caller may have won the race to re-register during that await;
+      // join it rather than opening a second LIVE on the same table.
+      const successor = this.pendingLive.get(table);
+      if (successor && successor.generation === generation) return successor.promise;
+    }
 
     const start = (async () => {
       try {
@@ -180,6 +272,14 @@ export class CrdtManager {
           `LIVE SELECT * FROM ${table}`,
         );
 
+        if (generation !== this.connectionGeneration) {
+          this.logger.debug(
+            { table, Category: 'sp00ky-client::CrdtManager::ensureTableSubscription' },
+            'Socket dropped while registering LIVE; discarding it'
+          );
+          return;
+        }
+
         const subscription = await this.remote.getClient().liveOf(uuid);
         subscription.subscribe((message) => {
           if (message.action === 'KILLED') return;
@@ -187,6 +287,8 @@ export class CrdtManager {
           this.dispatchRow(table, message.value as Record<string, unknown>);
         });
 
+        if (generation !== this.connectionGeneration) return;
+
         this.liveByTable.set(table, uuid);
         this.logger.info(
           { table, Category: 'sp00ky-client::CrdtManager::ensureTableSubscription' },
@@ -200,7 +302,7 @@ export class CrdtManager {
       }
     })();
 
-    this.pendingLive.set(table, start);
+    this.pendingLive.set(table, { promise: start, generation });
     try {
       await start;
     } finally {