@spooky-sync/core 0.0.1-canary.290 → 0.0.1-canary.291

package/src/modules/devtools/mutations.ts

@@ -0,0 +1,160 @@
+import type { ConnectionState, MutationEventType, SyncHealth } from '../../types';
+import type { OutboxItem, PendingWrite, TabRole } from '../../state/client-state';
+import { createdAtFromId } from '../../mutation/rows';
+
+/**
+ * Where a mutation is, as the DevTools Mutations tab shows it:
+ * - `pending`     in the outbox, not sent yet (or sent and not answered)
+ * - `retrying`    in the outbox after at least one failed push
+ * - `synced`      the server accepted it
+ * - `rolled-back` the server rejected it; the local change was undone and the
+ *                 row moved to the failed-writes tray
+ * - `dropped`     left the outbox without an answer this tab saw (a bucket
+ *                 switch, a sign-out, or its row was already gone)
+ */
+export type DevToolsMutationStatus = 'pending' | 'retrying' | 'synced' | 'rolled-back' | 'dropped';
+
+export interface DevToolsMutation {
+  /** `_00_pending_mutations:<ts>_<seq>_<tab>`, escaping removed. */
+  id: string;
+  op: MutationEventType;
+  recordId: string;
+  table: string;
+  /** Field names of the payload (the values stay in the page; see `mutationOp('get')`). */
+  fields?: string[];
+  status: DevToolsMutationStatus;
+  attempts: number;
+  queuedAt: number;
+  settledAt?: number;
+  error?: string;
+}
+
+/** What DevTools remembers about one mutation after it left the outbox. */
+export interface MutationHistoryEntry {
+  id: string;
+  op: MutationEventType;
+  recordId: string;
+  table: string;
+  fields?: string[];
+  queuedAt: number;
+  outcome?: { status: 'synced' | 'rolled-back'; at: number; error?: string };
+}
+
+export interface DevToolsDebouncedWrite {
+  key: string;
+  recordId: string;
+  table: string;
+  fields: string[];
+  since: number;
+  /** Mirrored to `_00_pending_writes`, so a reload inside the delay keeps it. */
+  durable: boolean;
+}
+
+export interface DevToolsMutationsState {
+  /** `follower` tabs never drain: the leader pushes their writes. */
+  role: TabRole;
+  connection: ConnectionState;
+  health: SyncHealth['status'];
+  consecutiveFailures: number;
+  lastError?: string;
+  counts: {
+    pending: number;
+    retrying: number;
+    debounced: number;
+    /** Rows in the persistent failed-writes tray, any session. */
+    failed: number;
+    /** This session, since DevTools attached. */
+    synced: number;
+    rolledBack: number;
+  };
+  /** Newest first, capped at `cap`. */
+  entries: DevToolsMutation[];
+  total: number;
+  debounced: DevToolsDebouncedWrite[];
+}
+
+export interface MutationsInput {
+  outbox: ReadonlyArray<OutboxItem>;
+  pendingWrites: Iterable<PendingWrite>;
+  failedCount: number;
+  tabRole: TabRole;
+  health: SyncHealth;
+  history: Iterable<MutationHistoryEntry>;
+  cap: number;
+}
+
+/** When a mutation was queued, from the timestamp its id starts with (0 for a legacy id). */
+export const queuedAtOf = (id: string): number => createdAtFromId(id) ?? 0;
+
+/** The tab's mutation picture: the live outbox over what DevTools saw leave it. */
+export function buildMutationsState(input: MutationsInput): DevToolsMutationsState {
+  const byId = new Map<string, DevToolsMutation>();
+  for (const h of input.history) {
+    byId.set(h.id, {
+      id: h.id,
+      op: h.op,
+      recordId: h.recordId,
+      table: h.table,
+      fields: h.fields,
+      status: h.outcome ? h.outcome.status : 'dropped',
+      attempts: 0,
+      queuedAt: h.queuedAt,
+      settledAt: h.outcome?.at,
+      error: h.outcome?.error,
+    });
+  }
+  for (const item of input.outbox) {
+    const seen = byId.get(item.id);
+    const status: DevToolsMutationStatus =
+      item.status === 'acked' ? 'synced' : item.attempts > 0 ? 'retrying' : 'pending';
+    byId.set(item.id, {
+      id: item.id,
+      op: item.type,
+      recordId: item.recordId,
+      table: item.table,
+      fields: seen?.fields,
+      status,
+      attempts: item.attempts,
+      queuedAt: seen?.queuedAt || queuedAtOf(item.id),
+      settledAt: item.ackedAt ?? seen?.settledAt,
+    });
+  }
+
+  const all = [...byId.values()].toSorted((a, b) => b.queuedAt - a.queuedAt || (a.id < b.id ? 1 : -1));
+  const count = (s: DevToolsMutationStatus) => all.filter((m) => m.status === s).length;
+  const debounced = [...input.pendingWrites].map((w) => ({
+    key: w.key,
+    recordId: w.recordId,
+    table: w.table,
+    fields: Object.keys(w.data),
+    since: w.firstAt,
+    durable: w.mirrorId !== null,
+  }));
+
+  return {
+    role: input.tabRole,
+    connection: input.health.connection,
+    health: input.health.status,
+    consecutiveFailures: input.health.consecutiveFailures,
+    lastError: input.health.error,
+    counts: {
+      pending: count('pending'),
+      retrying: count('retrying'),
+      debounced: debounced.length,
+      failed: input.failedCount,
+      synced: count('synced'),
+      rolledBack: count('rolled-back'),
+    },
+    entries: all.slice(0, input.cap),
+    total: all.length,
+    debounced,
+  };
+}
+
+/** Keep the newest `cap` entries of an insertion-ordered history map. */
+export function trimHistory(history: Map<string, MutationHistoryEntry>, cap: number): void {
+  for (const id of history.keys()) {
+    if (history.size <= cap) return;
+    history.delete(id);
+  }
+}

package/src/modules/devtools/notify-throttle.test.ts

@@ -8,7 +8,7 @@ import { DevToolsService } from './index';
  * requested per event — including one per local DB query — so without
  * coalescing a page load's few hundred local queries turn a few MB of rows into
  * GBs of short-lived large-object garbage and OOM the renderer. These tests pin
- * the coalescing, not the payload.
+ * the coalescing, not the payload. `onStateChanged` stands in for any trigger.
  */
 
 function harness(recordCount = 500) {
@@ -60,12 +60,26 @@ function harness(recordCount = 500) {
   };
 
   const service = new DevToolsService(local, remote, logger, { tables: [] } as any, auth, dataManager);
+  // Whatever the next push should carry; tests move it between requests.
+  const mutations: any = {
+    outbox: [],
+    pendingWrites: new Map(),
+    failedCount: 0,
+    tabRole: 'solo',
+    sync: { health: { status: 'healthy', consecutiveFailures: 0, everConnected: true, connection: 'connected' } },
+  };
+  service.setMutationSource({
+    state: () => mutations,
+    listFailed: async () => [],
+    retryFailed: async () => false,
+    discardFailed: async () => false,
+  });
   // Announce a consumer, exactly like the extension's page-script does.
   for (const cb of listeners) {
     cb({ source: fakeWindow, data: { type: 'SP00KY_DEVTOOLS_CONNECT' } });
   }
   const statePushes = () => posted.filter((m) => m.type === 'SP00KY_STATE_CHANGED');
-  return { service, statePushes, posted };
+  return { service, statePushes, posted, mutations };
 }
 
 afterEach(() => {
@@ -84,16 +98,14 @@ describe('DevToolsService state-push coalescing', () => {
     expect(statePushes().length).toBe(1);
   });
 
-  it('collapses a burst of per-query events into ONE trailing push', () => {
+  it('collapses a burst of change requests into ONE trailing push', () => {
     vi.useFakeTimers();
     const { service, statePushes } = harness();
     const before = statePushes().length;
 
-    // What a page load looks like: hundreds of LOCAL_QUERY events, each of which
-    // used to serialize the entire query state.
-    for (let i = 0; i < 400; i++) {
-      (service as any).logEvent('LOCAL_QUERY', { query: 'SELECT * FROM game', vars: {} });
-    }
+    // What a page load looks like: hundreds of requests, each of which used to
+    // serialize the entire query state.
+    for (let i = 0; i < 400; i++) service.onStateChanged();
     // Nothing extra yet — the burst is queued, not serialized 400 times.
     expect(statePushes().length).toBe(before);
 
@@ -106,21 +118,21 @@ describe('DevToolsService state-push coalescing', () => {
     const { service, statePushes } = harness();
     const before = statePushes().length;
 
-    (service as any).logEvent('A', {});
+    service.onStateChanged();
     vi.advanceTimersByTime(300);
     expect(statePushes().length).toBe(before + 1);
 
-    // An event arriving right after that flush is still inside the window, so it
+    // A request arriving right after that flush is still inside the window, so it
     // queues rather than pushing again...
-    (service as any).logEvent('B', {});
+    service.onStateChanged();
     expect(statePushes().length).toBe(before + 1);
     vi.advanceTimersByTime(300);
     expect(statePushes().length).toBe(before + 2);
 
-    // ...but once the tab has been idle past the window, the next event pushes
+    // ...but once the tab has been idle past the window, the next request pushes
     // straight away, so the panel never waits on a quiet app.
     vi.advanceTimersByTime(1000);
-    (service as any).logEvent('C', {});
+    service.onStateChanged();
     vi.advanceTimersByTime(0);
     expect(statePushes().length).toBe(before + 3);
   });
@@ -130,7 +142,7 @@ describe('DevToolsService state-push coalescing', () => {
     const { service, statePushes, posted } = harness();
     const before = statePushes().length;
 
-    (service as any).logEvent('A', {});
+    service.onStateChanged();
     (service as any).enabled = false; // panel closed while the push was queued
     vi.advanceTimersByTime(300);
     expect(statePushes().length).toBe(before);
@@ -139,16 +151,16 @@ describe('DevToolsService state-push coalescing', () => {
 
   it('serializes the LATEST state at flush time, not at request time', () => {
     vi.useFakeTimers();
-    const { service, statePushes } = harness();
+    const { service, statePushes, mutations } = harness();
+    vi.advanceTimersByTime(300);
 
-    (service as any).logEvent('FIRST', {});
-    (service as any).logEvent('SECOND', {});
+    service.onStateChanged();
+    mutations.failedCount = 1;
+    service.onStateChanged();
+    mutations.failedCount = 2;
     vi.advanceTimersByTime(300);
 
-    const last = statePushes().at(-1);
-    const types = last.state.eventsHistory.map((e: any) => e.eventType);
-    // Both events of the coalesced window are present in the single push.
-    expect(types).toContain('FIRST');
-    expect(types).toContain('SECOND');
+    // One push for the window, carrying what was true when it flushed.
+    expect(statePushes().at(-1).state.mutations.counts.failed).toBe(2);
   });
 });

package/src/modules/devtools/state-shape.test.ts

@@ -1,6 +1,13 @@
 import { describe, it, expect, vi, afterEach } from 'vitest';
 import { RecordId } from 'surrealdb';
 import { DevToolsService } from './index';
+import { initialHealth } from '../../state/client-state';
+import { LogTap, createLogger } from '../../services/logger/index';
+
+// Vitest runs in node, where `pino` resolves to its node build and ignores the
+// `browser` options the tap hangs off. Apps bundle the browser build.
+// The specifier is widened to `string`: pino ships no types for that entry.
+vi.mock('pino', async () => ({ default: (await import('pino/browser.js' as string)).default }));
 
 /**
  * The pushed state used to carry every view's full record set (and both
@@ -58,7 +65,7 @@ function harness(recordCount = 500) {
   const service = new DevToolsService(local, remote, logger, { tables: [] } as any, auth, dataManager);
   for (const cb of listeners) cb({ source: fakeWindow, data: { type: 'SP00KY_DEVTOOLS_CONNECT' } });
   const statePushes = () => posted.filter((m) => m.type === 'SP00KY_STATE_CHANGED');
-  return { service, statePushes, posted, fakeWindow, infoQueries };
+  return { service, statePushes, posted, fakeWindow, infoQueries, logger };
 }
 
 describe('DevTools pushed state shape', () => {
@@ -70,7 +77,7 @@ describe('DevTools pushed state shape', () => {
   it('carries counts and capped ids, never the rows', async () => {
     vi.useFakeTimers();
     const { service, statePushes } = harness(500);
-    service.onQueryUpdated({ queryId: 'x', records: [] });
+    service.onStateChanged();
     await vi.advanceTimersByTimeAsync(300);
     const push = statePushes().at(-1);
     expect(push).toBeDefined();
@@ -108,19 +115,20 @@ describe('DevTools pushed state shape', () => {
     expect(fakeWindow.__00__.getQueryRows(12345)).toBeNull();
   });
 
-  // Flaky under full-suite load only (the push that carries the event
-  // occasionally lands before the event is recorded); passes in isolation.
-  // DevTools moves to state-derived reads in a later commit; retried until then.
-  it('records a stream update as counts, not the membership array', { retry: 3 }, async () => {
-    vi.useFakeTimers();
-    const { service, statePushes } = harness(2);
-    service.onStreamUpdate({ queryHash: 'q1', localArray: [['a', 1], ['b', 1]], op: 'UPDATE' });
-    await vi.advanceTimersByTimeAsync(300);
-    const push = statePushes().at(-1);
-    const ev = push.state.eventsHistory.find((e: any) => e.eventType === 'STREAM_UPDATE');
-    expect(ev.payload.localCount).toBe(2);
-    expect(ev.payload.updates).toBeUndefined();
-    expect(ev.payload.localArray).toBeUndefined();
+  it('logs a stream update as counts and timings, never the membership array', () => {
+    const { service, logger } = harness(2);
+    const debug = vi.spyOn(logger, 'debug');
+    service.onStreamUpdate({ queryHash: 'q1', localArray: [['a', 1], ['b', 1]], op: 'UPDATE', storeApplyMs: 1.5 });
+    const [fields, msg] = debug.mock.calls.at(-1) as [any, string];
+    expect(msg).toBe('StreamUpdate');
+    expect(fields).toMatchObject({ queryHash: 'q1', op: 'UPDATE', localCount: 2, storeApplyMs: 1.5 });
+    expect(fields.localArray).toBeUndefined();
+  });
+
+  it('no longer keeps an event log, but still sends the field older panels key on', () => {
+    const { fakeWindow } = harness(1);
+    expect(fakeWindow.__00__.getState().eventsHistory).toEqual([]);
+    expect(fakeWindow.__00__.clearHistory).toBeUndefined();
   });
 
   it('ignores a synthetic re-materialize', async () => {
@@ -147,3 +155,109 @@ describe('DevTools pushed state shape', () => {
     expect(infoQueries.filter((q) => q.includes('INFO FOR DB')).length).toBe(connectRefreshes + 1);
   });
 });
+
+describe('DevTools mutations and logs', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+    vi.unstubAllGlobals();
+    vi.useRealTimers();
+  });
+
+  const mutationState = (): any => ({
+    outbox: [
+      {
+        id: '_00_pending_mutations:0000000001000_0001_t',
+        type: 'create',
+        recordId: 'thread:a',
+        table: 'thread',
+        status: 'pending',
+        ackedAt: null,
+        attempts: 0,
+      },
+    ],
+    pendingWrites: new Map(),
+    failedCount: 1,
+    tabRole: 'solo',
+    sync: { health: initialHealth('connected') },
+  });
+
+  it('pushes the outbox and what already left it', async () => {
+    vi.useFakeTimers();
+    const { service, statePushes } = harness(0);
+    service.setMutationSource({
+      state: mutationState,
+      listFailed: async () => [],
+      retryFailed: async () => true,
+      discardFailed: async () => false,
+    });
+    service.onMutation([
+      {
+        type: 'update',
+        mutation_id: new RecordId('_00_pending_mutations', '0000000002000_0002_t'),
+        record_id: new RecordId('thread', 'b'),
+        data: { title: 'a very long payload the push must not carry' },
+        tableName: 'thread',
+      },
+    ]);
+    service.onMutationOutcome({
+      mutationId: '_00_pending_mutations:0000000002000_0002_t',
+      recordId: 'thread:b',
+      eventType: 'update',
+      status: 'rolled-back',
+      error: 'denied',
+    });
+    await vi.advanceTimersByTimeAsync(300);
+    const m = statePushes().at(-1).state.mutations;
+    expect(m.counts).toMatchObject({ pending: 1, rolledBack: 1, failed: 1 });
+    expect(m.entries[0]).toMatchObject({
+      recordId: 'thread:b',
+      status: 'rolled-back',
+      error: 'denied',
+      fields: ['title'],
+      queuedAt: 2000,
+    });
+    expect(JSON.stringify(m)).not.toContain('very long payload');
+  });
+
+  it('answers the tray ops, with a reason when the row is gone', async () => {
+    const { service, fakeWindow } = harness(0);
+    service.setMutationSource({
+      state: mutationState,
+      listFailed: async () => [],
+      retryFailed: async () => true,
+      discardFailed: async () => false,
+    });
+    expect(await fakeWindow.__00__.mutationOp('retry', { id: 'm1' })).toEqual({ success: true });
+    expect(await fakeWindow.__00__.mutationOp('discard', { id: 'm1' })).toMatchObject({
+      success: false,
+      error: expect.stringContaining('not in the failed tray'),
+    });
+    expect(await fakeWindow.__00__.mutationOp('listFailed')).toEqual({ success: true, failed: [] });
+  });
+
+  it('pushes new log lines as deltas and keeps them out of the state', async () => {
+    vi.useFakeTimers();
+    vi.spyOn(console, 'log').mockImplementation(() => {});
+    const { service, posted, fakeWindow } = harness(0);
+    const tap = new LogTap('info');
+    const logger = createLogger('info', undefined, tap);
+    logger.info('before attach');
+    service.setLogTap(tap);
+    logger.warn('one');
+    logger.info('two');
+    await vi.advanceTimersByTimeAsync(300);
+    const pushes = posted.filter((m) => m.type === 'SP00KY_LOGS');
+    expect(pushes).toHaveLength(1);
+    expect(pushes[0].entries.map((e: any) => e.msg)).toEqual(['one', 'two']);
+    expect(fakeWindow.__00__.getState().logs).toEqual({ head: 3, consoleLevel: 'info', captureLevel: 'info' });
+    const backlog = fakeWindow.__00__.logOp('read', {});
+    expect(backlog.entries.map((e: any) => e.msg)).toEqual(['before attach', 'one', 'two']);
+    expect(fakeWindow.__00__.logOp('setCaptureLevel', { level: 'debug' })).toMatchObject({
+      success: true,
+      captureLevel: 'debug',
+    });
+    logger.debug('now captured');
+    expect(fakeWindow.__00__.logOp('read', { after: 3 }).entries.map((e: any) => e.msg)).toEqual(['now captured']);
+    expect(fakeWindow.__00__.logOp('setCaptureLevel', { level: 'loud' }).success).toBe(false);
+  });
+});

package/src/services/database/database.ts

@@ -133,7 +133,9 @@ export abstract class AbstractDatabaseService {
       await this.beforeQuery();
       const startTime = performance.now();
       try {
-        this.logger.debug(
+        // Trace: the finished statement is logged at debug by the client,
+        // from the query event below. This line is for a statement that hangs.
+        this.logger.trace(
           { query, vars, Category: 'sp00ky-client::Database::query' },
           'Executing query'
         );

package/src/services/logger/index.test.ts

@@ -0,0 +1,132 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { LogTap, createLogger, stringifyLog } from './index';
+
+// Vitest runs in node, where `pino` resolves to its node build and ignores the
+// `browser` options the tap hangs off. Apps bundle the browser build.
+// The specifier is widened to `string`: pino ships no types for that entry.
+vi.mock('pino', async () => ({ default: (await import('pino/browser.js' as string)).default }));
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  vi.unstubAllGlobals();
+});
+
+function silentConsole() {
+  return vi.spyOn(console, 'log').mockImplementation(() => {});
+}
+
+describe('LogTap', () => {
+  it('records what the logger writes, child bindings included', () => {
+    silentConsole();
+    const tap = new LogTap('info');
+    const logger = createLogger('info', undefined, tap);
+    logger.child({ service: 'Database' }).warn({ Category: 'x' }, 'slow query');
+    logger.debug('not at this level');
+    const { entries, head } = tap.read();
+    expect(entries).toHaveLength(1);
+    expect(head).toBe(1);
+    expect(entries[0]).toMatchObject({ seq: 1, level: 40, msg: 'slow query' });
+    expect(JSON.parse(entries[0].line)).toMatchObject({ service: 'Database', Category: 'x' });
+  });
+
+  it('captures below the console level without printing it, on existing children too', () => {
+    const printed = silentConsole();
+    const tap = new LogTap('info');
+    const logger = createLogger('info', undefined, tap);
+    const child = logger.child({ service: 'Sync' });
+    child.debug('before');
+    tap.setCaptureLevel('debug');
+    child.debug('after');
+    logger.info('shown');
+    expect(tap.read().entries.map((e) => e.msg)).toEqual(['after', 'shown']);
+    expect(printed).toHaveBeenCalledTimes(1);
+    expect(String(printed.mock.calls[0][0])).toContain('shown');
+  });
+
+  it('keeps the capture level for the tab session', () => {
+    const store = new Map<string, string>();
+    vi.stubGlobal('sessionStorage', {
+      getItem: (k: string) => store.get(k) ?? null,
+      setItem: (k: string, v: string) => void store.set(k, v),
+      removeItem: (k: string) => void store.delete(k),
+    });
+    new LogTap('info').setCaptureLevel('trace');
+    expect(new LogTap('info').captureLevel).toBe('trace');
+    new LogTap('info').setCaptureLevel('info');
+    expect(store.size).toBe(0);
+  });
+
+  it('is a bounded ring that reports what a slow reader missed', () => {
+    silentConsole();
+    const tap = new LogTap('info');
+    const logger = createLogger('info', undefined, tap);
+    for (let i = 0; i < LogTap.CAPACITY + 10; i++) logger.info(`line ${i}`);
+    const all = tap.read();
+    expect(all.entries).toHaveLength(LogTap.CAPACITY);
+    expect(all.dropped).toBe(10);
+    const delta = tap.read(all.head - 2);
+    expect(delta.entries.map((e) => e.msg)).toEqual([`line ${LogTap.CAPACITY + 8}`, `line ${LogTap.CAPACITY + 9}`]);
+    expect(delta.dropped).toBe(0);
+  });
+
+  it('does not count cleared lines as dropped', () => {
+    silentConsole();
+    const tap = new LogTap('info');
+    const logger = createLogger('info', undefined, tap);
+    logger.info('a');
+    logger.info('b');
+    tap.clear();
+    logger.info('c');
+    expect(tap.read(0)).toMatchObject({ dropped: 0, head: 3 });
+    expect(tap.read(0).entries.map((e) => e.msg)).toEqual(['c']);
+  });
+
+  it('caps a huge line', () => {
+    silentConsole();
+    const tap = new LogTap('info');
+    createLogger('info', undefined, tap).info({ blob: 'x'.repeat(LogTap.LINE_MAX * 2) }, 'big');
+    const [entry] = tap.read().entries;
+    expect(entry.line.length).toBe(LogTap.LINE_MAX + 1);
+    expect(entry.msg).toBe('big');
+  });
+
+  it('notifies listeners and survives one that throws', () => {
+    silentConsole();
+    const tap = new LogTap('info');
+    const logger = createLogger('info', undefined, tap);
+    const seen: number[] = [];
+    tap.subscribe(() => {
+      throw new Error('listener bug');
+    });
+    tap.subscribe(() => seen.push(tap.head));
+    expect(() => logger.info('x')).not.toThrow();
+    expect(seen).toEqual([1]);
+  });
+
+  it('keeps the otel transmit at the configured level when capture goes lower', () => {
+    silentConsole();
+    const sent: string[] = [];
+    const tap = new LogTap('info');
+    const logger = createLogger('info', { send: (level) => void sent.push(level) }, tap);
+    tap.setCaptureLevel('debug');
+    logger.debug('d');
+    logger.info('i');
+    expect(sent).toEqual(['info']);
+  });
+});
+
+describe('stringifyLog', () => {
+  it('keeps errors readable and never throws on bigints or cycles', () => {
+    const o: Record<string, unknown> = { err: new Error('boom'), n: 10n };
+    o.self = o;
+    const parsed = JSON.parse(stringifyLog(o));
+    expect(parsed.err).toMatchObject({ type: 'Error', message: 'boom' });
+    expect(parsed.n).toBe('10');
+    expect(parsed.self).toBe('[Circular]');
+  });
+
+  it('does not mistake a shared reference for a cycle', () => {
+    const shared = { a: 1 };
+    expect(JSON.parse(stringifyLog({ x: shared, y: shared }))).toEqual({ x: { a: 1 }, y: { a: 1 } });
+  });
+});