@spooky-sync/core 0.0.1-canary.21 → 0.0.1-canary.211

package/src/modules/sync/sync.health.test.ts

@@ -0,0 +1,149 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Sp00kySync } from './sync';
+
+// The idle list-ref poll is the only health signal that runs on a quiet page.
+// These tests exercise `pollListRefForActiveQueries` -> `recordSyncOutcome` in
+// isolation: a run of network-failed cycles degrades, and a single clean cycle
+// recovers WITHOUT any mutation (the reported bug). Construction is cheap —
+// Sp00kySync's constructor only stores refs and calls logger.child; no timers or
+// I/O start until init(), which we never call.
+
+const CONNECTION_UNAVAILABLE =
+  'You must be connected to a SurrealDB instance before performing this operation';
+
+function makeSync(hashes: string[]) {
+  const logger: any = {
+    child: () => logger,
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    trace: () => {},
+  };
+  const remote: any = { query: vi.fn().mockResolvedValue([true]) };
+  const dataModule: any = { getActiveQueryHashes: () => hashes };
+
+  const sync = new Sp00kySync(
+    {} as any,
+    remote,
+    {} as any,
+    dataModule,
+    {} as any,
+    logger,
+    { degradeAfterConsecutiveFailures: 3 }
+  );
+
+  // `refetchListRefForQuery` is what the poll calls per active hash; stub it so
+  // the test controls per-cycle reachability. `poll` invokes the private method.
+  const refetch = vi.fn();
+  (sync as any).refetchListRefForQuery = refetch;
+  const poll = () => (sync as any).pollListRefForActiveQueries() as Promise<boolean>;
+
+  return { sync, remote, refetch, poll };
+}
+
+describe('sync health via idle poll', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('degrades after N consecutive network-failed poll cycles', async () => {
+    const { sync, refetch, poll } = makeSync(['h1']);
+    refetch.mockRejectedValue(new Error(CONNECTION_UNAVAILABLE));
+
+    await poll();
+    expect(sync.syncHealth.status).toBe('healthy');
+    await poll();
+    expect(sync.syncHealth.status).toBe('healthy');
+    await poll();
+    expect(sync.syncHealth.status).toBe('degraded');
+    expect(sync.syncHealth.kind).toBe('network');
+  });
+
+  it('recovers on the next clean poll cycle — no mutation needed', async () => {
+    const { sync, refetch, poll } = makeSync(['h1']);
+    refetch.mockRejectedValue(new Error(CONNECTION_UNAVAILABLE));
+    await poll();
+    await poll();
+    await poll();
+    expect(sync.syncHealth.status).toBe('degraded');
+
+    // Connectivity returns; a plain idle poll (no user action) clears it.
+    refetch.mockResolvedValue(true);
+    await poll();
+    expect(sync.syncHealth.status).toBe('healthy');
+  });
+
+  it('does not degrade on application errors (server was reached)', async () => {
+    const { sync, refetch, poll } = makeSync(['h1']);
+    refetch.mockRejectedValue(new Error('Permission denied'));
+    await poll();
+    await poll();
+    await poll();
+    await poll();
+    expect(sync.syncHealth.status).toBe('healthy');
+  });
+
+  it('counts a mixed cycle (one reachable hash) as reached', async () => {
+    const { sync, refetch, poll } = makeSync(['h1', 'h2']);
+    // First degrade via all-network cycles.
+    refetch.mockRejectedValue(new Error(CONNECTION_UNAVAILABLE));
+    await poll();
+    await poll();
+    await poll();
+    expect(sync.syncHealth.status).toBe('degraded');
+
+    // Now one hash succeeds, the other still network-fails → reached → healthy.
+    refetch.mockReset();
+    refetch
+      .mockResolvedValueOnce(true)
+      .mockRejectedValueOnce(new Error(CONNECTION_UNAVAILABLE));
+    await poll();
+    expect(sync.syncHealth.status).toBe('healthy');
+  });
+
+  it('probes RETURN true when there are no active queries', async () => {
+    const { sync, remote, poll } = makeSync([]);
+    remote.query.mockRejectedValue(new Error(CONNECTION_UNAVAILABLE));
+    await poll();
+    await poll();
+    await poll();
+    expect(remote.query).toHaveBeenCalledWith('RETURN true');
+    expect(sync.syncHealth.status).toBe('degraded');
+
+    remote.query.mockResolvedValue([true]);
+    await poll();
+    expect(sync.syncHealth.status).toBe('healthy');
+  });
+
+  it('leaves everConnected false through a cold-start failure run', async () => {
+    const { sync, refetch, poll } = makeSync(['h1']);
+    expect(sync.syncHealth.everConnected).toBe(false);
+
+    // Server never reached: 3 failed cycles degrade, but this is the initial
+    // "connecting" phase, not a lost connection — everConnected stays false.
+    refetch.mockRejectedValue(new Error(CONNECTION_UNAVAILABLE));
+    await poll();
+    await poll();
+    await poll();
+    expect(sync.syncHealth.status).toBe('degraded');
+    expect(sync.syncHealth.everConnected).toBe(false);
+  });
+
+  it('latches everConnected on the first success and keeps it through a later degrade', async () => {
+    const { sync, refetch, poll } = makeSync(['h1']);
+
+    // First successful round reaches the server: connecting phase is over.
+    refetch.mockResolvedValue(true);
+    await poll();
+    expect(sync.syncHealth.status).toBe('healthy');
+    expect(sync.syncHealth.everConnected).toBe(true);
+
+    // Connection later drops: degraded now reflects a REAL lost connection.
+    refetch.mockReset();
+    refetch.mockRejectedValue(new Error(CONNECTION_UNAVAILABLE));
+    await poll();
+    await poll();
+    await poll();
+    expect(sync.syncHealth.status).toBe('degraded');
+    expect(sync.syncHealth.everConnected).toBe(true);
+  });
+});

package/src/modules/sync/sync.heartbeat.test.ts

@@ -0,0 +1,80 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { RecordId } from 'surrealdb';
+import { Sp00kySync } from './sync';
+
+/**
+ * `fn::query::heartbeat` is an `UPDATE $id SET ...`. Against a record that no
+ * longer exists it matches nothing and returns an empty array — it does NOT
+ * recreate the row. Verified against the deployed function:
+ *
+ *     RETURN fn::query::heartbeat(_00_query:definitely_not_a_real_row_xyz);
+ *     -- (0 rows)
+ *
+ * So an unchecked heartbeat cannot tell "refreshed" from "the row I am
+ * refreshing is gone", and a client whose row was reclaimed by the TTL sweep
+ * beats against nothing forever: no membership, no edges, no re-registration.
+ * The page then renders as though the data had been deleted — reported as
+ * "Game not found" on a game that was open and working.
+ *
+ * This is reachable in ordinary use: the sweep expires on `lastActiveAt + ttl`
+ * while the heartbeat runs on a timer browsers throttle hard in background
+ * tabs, so a second window left idle past its TTL is the normal way in.
+ */
+
+function makeSync(heartbeatResult: unknown) {
+  const logger: any = {
+    child: () => logger,
+    debug: () => {}, info: () => {}, warn: () => {}, error: () => {}, trace: () => {},
+  };
+  const remote: any = { query: vi.fn().mockResolvedValue(heartbeatResult) };
+  const queryState: any = { config: { id: new RecordId('_00_query', 'h1') } };
+  const dataModule: any = { getQueryByHash: vi.fn().mockReturnValue(queryState) };
+
+  const sync = new Sp00kySync({} as any, remote, {} as any, dataModule, {} as any, logger);
+  const enqueueDownEvent = vi.fn();
+  (sync as any).enqueueDownEvent = enqueueDownEvent;
+
+  return { sync, remote, dataModule, enqueueDownEvent };
+}
+
+describe('heartbeatQuery — noticing a reclaimed row', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('re-registers when the row it beat against is gone', async () => {
+    // `UPDATE` on a deleted record: one statement, zero updated records.
+    const { sync, enqueueDownEvent } = makeSync([[]]);
+
+    await sync.heartbeatQuery('h1');
+
+    expect(enqueueDownEvent).toHaveBeenCalledWith({
+      type: 'register',
+      payload: { hash: 'h1' },
+    });
+  });
+
+  it('does nothing extra on a healthy heartbeat', async () => {
+    const { sync, enqueueDownEvent } = makeSync([[{ id: 'x', lastActiveAt: 'now' }]]);
+
+    await sync.heartbeatQuery('h1');
+
+    expect(enqueueDownEvent).not.toHaveBeenCalled();
+  });
+
+  it('does not re-register on an unrecognised result shape', async () => {
+    // Only an explicitly EMPTY update result means "the row is gone". Anything
+    // else — a driver returning null, a shape change — must not be read as
+    // deletion, or every heartbeat would re-register the whole working set.
+    for (const shape of [null, undefined, [], [null], ['unexpected']]) {
+      const { sync, enqueueDownEvent } = makeSync(shape);
+      await sync.heartbeatQuery('h1');
+      expect(enqueueDownEvent, `shape ${JSON.stringify(shape)}`).not.toHaveBeenCalled();
+    }
+  });
+
+  it('still throws for a query that is no longer registered locally', async () => {
+    const { sync, dataModule } = makeSync([[]]);
+    dataModule.getQueryByHash.mockReturnValue(undefined);
+
+    await expect(sync.heartbeatQuery('gone')).rejects.toThrow();
+  });
+});

package/src/modules/sync/sync.live-removal.test.ts

@@ -0,0 +1,175 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { RecordId } from 'surrealdb';
+import { Sp00kySync } from './sync';
+
+// A LIVE `_00_list_ref` DELETE is how one window learns another deleted a record.
+//
+// `remoteArray` — the authoritative membership rows are now rendered FROM — used
+// to be written only by registration and the poll, so a LIVE removal left the
+// departed id in the list (in memory AND persisted) until the next poll tick: up
+// to 5s of showing a deleted row, and on a page that then went offline, forever.
+//
+// A removal-only diff also gets no re-render for free: `runSyncForQuery` leaves
+// `fetching` false, and a removal needs no record fetch to trigger a stream
+// update, so the notify has to be forced.
+
+function makeSync(opts: { membershipKnown?: boolean } = {}) {
+  const logger: any = {
+    child: () => logger,
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    trace: () => {},
+  };
+  const queryId = new RecordId('_00_query', 'h1');
+  const queryState: any = {
+    config: {
+      id: queryId,
+      localArray: [
+        ['thread:a', 1],
+        ['thread:b', 1],
+      ],
+      remoteArray: [
+        ['thread:a', 1],
+        ['thread:b', 1],
+      ],
+      membershipKnown: opts.membershipKnown ?? true,
+      membershipKey: 'stable-key',
+    },
+  };
+
+  const updateQueryRemoteArray = vi.fn(async (_h: string, next: any) => {
+    queryState.config.remoteArray = next;
+  });
+  const notifyQuerySynced = vi.fn().mockResolvedValue(undefined);
+  const dataModule: any = {
+    scheduleRematerialize: vi.fn(),
+    getQueryById: vi.fn().mockReturnValue(queryState),
+    getQueryByHash: vi.fn().mockReturnValue(queryState),
+    updateQueryRemoteArray,
+    notifyQuerySynced,
+    getActiveQueryHashes: () => ['h1'],
+    getPendingRecordIds: async () => ({ writes: new Set(), deletes: new Set() }),
+  };
+
+  const sync = new Sp00kySync(
+    {} as any,
+    { query: vi.fn() } as any,
+    {} as any,
+    dataModule,
+    {} as any,
+    logger
+  );
+  // `runSyncForQuery` drives the engine + scheduler; both are out of scope here.
+  (sync as any).runSyncForQuery = vi.fn().mockResolvedValue(undefined);
+
+  const live = (action: 'CREATE' | 'UPDATE' | 'DELETE', id: string, version: number) =>
+    (sync as any).handleRemoteListRefChange(
+      action,
+      queryId,
+      new RecordId('thread', id),
+      version
+    ) as Promise<void>;
+
+  return { sync, queryState, updateQueryRemoteArray, notifyQuerySynced, live };
+}
+
+describe('LIVE list_ref removal → membership', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('drops the removed id from remoteArray immediately', async () => {
+    const { queryState, updateQueryRemoteArray, live } = makeSync();
+
+    await live('DELETE', 'b', 2);
+
+    expect(updateQueryRemoteArray).toHaveBeenCalledWith('h1', [['thread:a', 1]]);
+    expect(queryState.config.remoteArray).toEqual([['thread:a', 1]]);
+  });
+
+  it('forces a re-render for a removal-only diff', async () => {
+    const { notifyQuerySynced, live } = makeSync();
+    await live('DELETE', 'b', 2);
+    expect(notifyQuerySynced).toHaveBeenCalledWith('h1');
+  });
+
+  it('does not force a re-render when rows were added (the stream update covers it)', async () => {
+    const { notifyQuerySynced, live } = makeSync();
+    await live('CREATE', 'c', 1);
+    expect(notifyQuerySynced).not.toHaveBeenCalled();
+  });
+
+  it('adds a newly-arrived id to membership', async () => {
+    const { updateQueryRemoteArray, live } = makeSync();
+
+    await live('CREATE', 'c', 1);
+
+    expect(updateQueryRemoteArray).toHaveBeenCalledWith('h1', [
+      ['thread:a', 1],
+      ['thread:b', 1],
+      ['thread:c', 1],
+    ]);
+  });
+
+  // Every tab that ingested a write optimistically (its own, or one relayed
+  // from another tab) already holds the row at the server's version, so the
+  // fetch diff is empty. Membership still has to be recorded, or the row lives
+  // on the settled-write grace alone until the poll catches it.
+  it('adds membership for a row the circuit already holds at the server version', async () => {
+    const { queryState, updateQueryRemoteArray, sync, live } = makeSync();
+    queryState.config.localArray = [
+      ['thread:a', 1],
+      ['thread:b', 1],
+      ['thread:c', 1],
+    ];
+
+    await live('CREATE', 'c', 1);
+
+    expect(updateQueryRemoteArray).toHaveBeenCalledWith('h1', [
+      ['thread:a', 1],
+      ['thread:b', 1],
+      ['thread:c', 1],
+    ]);
+    // …without a refetch: the diff handed to the sync is empty.
+    expect((sync as any).runSyncForQuery).toHaveBeenCalledWith('h1', {
+      added: [],
+      updated: [],
+      removed: [],
+    });
+  });
+
+  it('records a bumped version on UPDATE without rewriting an unchanged list', async () => {
+    const { updateQueryRemoteArray, live } = makeSync();
+
+    await live('UPDATE', 'b', 1);
+    expect(updateQueryRemoteArray).not.toHaveBeenCalled();
+
+    await live('UPDATE', 'b', 2);
+    expect(updateQueryRemoteArray).toHaveBeenCalledWith('h1', [
+      ['thread:a', 1],
+      ['thread:b', 2],
+    ]);
+  });
+
+  it('leaves membership alone while it is still unknown', async () => {
+    // Nothing authoritative has arrived yet, so there is no list to amend —
+    // registration will supply the whole thing shortly.
+    const { updateQueryRemoteArray, live } = makeSync({ membershipKnown: false });
+    await live('DELETE', 'b', 2);
+    expect(updateQueryRemoteArray).not.toHaveBeenCalled();
+  });
+
+  it('is a no-op for an unknown query', async () => {
+    const { sync, updateQueryRemoteArray } = makeSync();
+    (sync as any).dataModule.getQueryById = vi.fn().mockReturnValue(undefined);
+
+    await (sync as any).handleRemoteListRefChange(
+      'DELETE',
+      new RecordId('_00_query', 'other'),
+      new RecordId('thread', 'b'),
+      2
+    );
+
+    expect(updateQueryRemoteArray).not.toHaveBeenCalled();
+  });
+});

package/src/modules/sync/sync.reconnect.test.ts

@@ -0,0 +1,145 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Sp00kySync } from './sync';
+
+// The reconnect handler re-registers active queries and re-issues the ref LIVE.
+// It must fire on BOTH drop paths, and the distinction is the whole bug:
+//
+//   - recovered drop:  error -> reconnecting -> connected   (no `disconnected`!)
+//   - gave-up drop:    error -> disconnected -> (supervisor) -> connected
+//
+// Watching only `disconnected` therefore misses every *successful* reconnect —
+// the common case — and leaves the dead server-side LIVE in place with the
+// list_ref poll silently the only sync path.
+
+/** Minimal stand-in for the SDK's event publisher. */
+function makeClient() {
+  const listeners = new Map<string, Array<(...a: any[]) => void>>();
+  return {
+    subscribe(event: string, cb: (...a: any[]) => void) {
+      const arr = listeners.get(event) ?? [];
+      arr.push(cb);
+      listeners.set(event, arr);
+      return () => {
+        /* noop */
+      };
+    },
+    emit(event: string, ...args: any[]) {
+      for (const cb of listeners.get(event) ?? []) cb(...args);
+    },
+    liveOf: async () => ({ subscribe: () => () => {} }),
+  };
+}
+
+function makeSync(hashes: string[], userId: string | null = 'user:alice') {
+  const logger: any = {
+    child: () => logger,
+    debug: () => {},
+    info: () => {},
+    warn: () => {},
+    error: () => {},
+    trace: () => {},
+  };
+  const client = makeClient();
+  const status = { value: 'connected' as string };
+  const remote: any = {
+    query: vi.fn().mockResolvedValue(['live-uuid']),
+    getClient: () => client,
+    getStatus: () => status.value,
+  };
+  const dataModule: any = {
+    getActiveQueryHashes: () => hashes,
+    getCurrentUserId: () => userId,
+  };
+
+  const sync = new Sp00kySync({} as any, remote, {} as any, dataModule, {} as any, logger);
+
+  // `subscribeToReconnect` is normally wired from init(), which would also start
+  // timers and load the outbox. Call it directly instead.
+  (sync as any).currentUserId = userId;
+  (sync as any).subscribeToReconnect();
+
+  const enqueued: any[] = [];
+  (sync as any).scheduler = { enqueueDownEvent: (e: any) => enqueued.push(e) };
+
+  return { sync, client, remote, enqueued, status };
+}
+
+/** Let the `connected` handler's un-awaited `restartRefLiveQuery()` chain run. */
+const flush = () => new Promise((r) => setTimeout(r, 0));
+
+describe('sync reconnect re-subscription', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('re-registers queries and restarts LIVE on a recovered drop (reconnecting -> connected)', async () => {
+    const { client, remote, enqueued } = makeSync(['h1', 'h2']);
+
+    // The SDK's own reconnect: no `disconnected` is ever published.
+    client.emit('reconnecting');
+    client.emit('connected');
+    await flush();
+
+    expect(enqueued).toEqual([
+      { type: 'register', payload: { hash: 'h1' } },
+      { type: 'register', payload: { hash: 'h2' } },
+    ]);
+    const sqls = (remote.query as any).mock.calls.map((c: any[]) => c[0]);
+    expect(sqls.some((s: string) => s.startsWith('LIVE SELECT'))).toBe(true);
+  });
+
+  it('re-registers queries and restarts LIVE after the SDK gives up (disconnected -> connected)', async () => {
+    const { client, remote, enqueued } = makeSync(['h1']);
+
+    client.emit('disconnected');
+    client.emit('connected');
+    await flush();
+
+    expect(enqueued).toEqual([{ type: 'register', payload: { hash: 'h1' } }]);
+    const sqls = (remote.query as any).mock.calls.map((c: any[]) => c[0]);
+    expect(sqls.some((s: string) => s.startsWith('LIVE SELECT'))).toBe(true);
+  });
+
+  it('does nothing on the initial connect', async () => {
+    const { client, remote, enqueued } = makeSync(['h1']);
+
+    client.emit('connected');
+    await flush();
+
+    expect(enqueued).toEqual([]);
+    expect(remote.query).not.toHaveBeenCalled();
+  });
+
+  it('only reacts once per drop', async () => {
+    const { client, enqueued } = makeSync(['h1']);
+
+    client.emit('reconnecting');
+    client.emit('connected');
+    await flush();
+    // A spurious second `connected` (e.g. a re-published event) must not
+    // trigger a second refetch storm.
+    client.emit('connected');
+    await flush();
+
+    expect(enqueued).toHaveLength(1);
+  });
+
+  it("does not KILL the dead session's LIVE uuid on reconnect", async () => {
+    const { sync, client, remote } = makeSync(['h1']);
+    // A LIVE was running before the drop. Its uuid belongs to the old
+    // WebSocket session, so KILLing it on the new socket is pointless work
+    // queued ahead of the restart that actually matters.
+    const unsub = vi.fn();
+    (sync as any).currentLiveQueryUuid = 'stale-uuid';
+    (sync as any).liveQueryUnsubscribe = unsub;
+
+    client.emit('reconnecting');
+    expect(unsub).toHaveBeenCalled();
+    expect((sync as any).currentLiveQueryUuid).toBeNull();
+
+    client.emit('connected');
+    await flush();
+
+    const sqls = (remote.query as any).mock.calls.map((c: any[]) => c[0]);
+    expect(sqls.some((q: string) => q.includes('KILL'))).toBe(false);
+    expect(sqls.some((q: string) => q.startsWith('LIVE SELECT'))).toBe(true);
+  });
+});

package/src/modules/sync/sync.subquery.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { RecordId } from 'surrealdb';
+import { Sp00kySync } from './sync';
+import { buildSubqueryListRefSelect } from './utils';
+import { encodeRecordId } from '../../utils/index';
+
+// Guards the CLIENT half of `.related()` (author/comments) delivery: given
+// subquery-child edges on the server (`_00_list_ref…` rows with
+// `parent IS NOT NONE`), `syncSubqueryChildren` MUST pull the child bodies
+// through the sync engine so a later re-materialization attaches them to the
+// parent. If this stops forwarding the child ids, related fields come back
+// empty (threads render with an "Anonymous" author, comments vanish) even
+// though the server wrote the edges correctly.
+
+function makeSync() {
+  const logger: any = {
+    child: () => logger,
+    debug: () => {}, info: () => {}, warn: () => {}, error: () => {}, trace: () => {},
+  };
+  const remote: any = { query: vi.fn() };
+  const queryId = new RecordId('_00_query', 'h1');
+  const queryState: any = { config: { id: queryId, subqueryRemoteArray: [] } };
+  const dataModule: any = { getQueryByHash: vi.fn().mockReturnValue(queryState) };
+
+  const sync = new Sp00kySync(
+    {} as any, remote, {} as any, dataModule, {} as any, logger,
+  );
+
+  // syncEngine is constructed internally; replace it with a spy.
+  const syncRecords = vi.fn().mockResolvedValue(undefined);
+  (sync as any).syncEngine = { syncRecords };
+  // Pin the resolved per-user list_ref table (auth routing is out of scope here).
+  (sync as any).listRefTable = () => '_00_list_ref_user_x';
+
+  const run = (hash: string) => (sync as any).syncSubqueryChildren(hash) as Promise<void>;
+  return { remote, syncRecords, queryState, queryId, run };
+}
+
+describe('syncSubqueryChildren — related-child delivery', () => {
+  beforeEach(() => vi.clearAllMocks());
+
+  it('reads the subquery edges (parent IS NOT NONE) scoped to the query id', async () => {
+    const { remote, run, queryId } = makeSync();
+    remote.query.mockResolvedValue([[]]);
+
+    await run('h1');
+
+    expect(remote.query).toHaveBeenCalledWith(
+      buildSubqueryListRefSelect('_00_list_ref_user_x'),
+      { in: queryId }
+    );
+  });
+
+  it('forwards each subquery child id to the sync engine so its body is cached', async () => {
+    const { remote, syncRecords, run } = makeSync();
+    // Server has one author child edge for this query.
+    remote.query.mockResolvedValue([[
+      { out: new RecordId('user', 'u'), version: 1 },
+    ]]);
+
+    await run('h1');
+
+    expect(syncRecords).toHaveBeenCalledTimes(1);
+    const arg = syncRecords.mock.calls[0][0];
+    expect(arg.added).toHaveLength(1);
+    expect(encodeRecordId(arg.added[0].id)).toBe('user:u');
+    expect(arg.added[0].version).toBe(1);
+    expect(arg.removed).toEqual([]); // shared child bodies are never deleted here
+  });
+
+  it('is idempotent: unchanged edges do not refetch bodies', async () => {
+    const { remote, syncRecords, run, queryState } = makeSync();
+    queryState.config.subqueryRemoteArray = [['user:u', 1]];
+    remote.query.mockResolvedValue([[
+      { out: new RecordId('user', 'u'), version: 1 },
+    ]]);
+
+    await run('h1');
+
+    expect(syncRecords).not.toHaveBeenCalled();
+  });
+});