@spooky-sync/core 0.0.1-canary.32 → 0.0.1-canary.320

package/src/modules/devtools/mutations.test.ts

@@ -0,0 +1,92 @@
+import { describe, it, expect } from 'vitest';
+import type { OutboxItem, PendingWrite } from '../../state/client-state';
+import { initialHealth } from '../../state/client-state';
+import { buildMutationsState, trimHistory, type MutationHistoryEntry } from './mutations';
+
+const id = (ts: number, n = 1) => `_00_pending_mutations:${String(ts).padStart(13, '0')}_${String(n).padStart(4, '0')}_tab`;
+
+const item = (over: Partial<OutboxItem> & { id: string }): OutboxItem => ({
+  type: 'update',
+  recordId: 'thread:a',
+  table: 'thread',
+  status: 'pending',
+  ackedAt: null,
+  attempts: 0,
+  ...over,
+});
+
+const build = (over: Partial<Parameters<typeof buildMutationsState>[0]> = {}) =>
+  buildMutationsState({
+    outbox: [],
+    pendingWrites: [],
+    failedCount: 0,
+    tabRole: 'solo',
+    health: initialHealth('connected'),
+    history: [],
+    cap: 200,
+    ...over,
+  });
+
+describe('buildMutationsState', () => {
+  it('reads status off the outbox, queued time off the id', () => {
+    const s = build({
+      outbox: [
+        item({ id: id(1000) }),
+        item({ id: id(2000), attempts: 3 }),
+        item({ id: id(3000), status: 'acked', ackedAt: 3500 }),
+      ],
+    });
+    expect(s.entries.map((e) => [e.queuedAt, e.status])).toEqual([
+      [3000, 'synced'],
+      [2000, 'retrying'],
+      [1000, 'pending'],
+    ]);
+    expect(s.entries[0].settledAt).toBe(3500);
+    expect(s.counts).toMatchObject({ pending: 1, retrying: 1, synced: 1, rolledBack: 0 });
+  });
+
+  it('keeps what left the outbox, and the live outbox wins over history', () => {
+    const history: MutationHistoryEntry[] = [
+      { id: id(1000), op: 'create', recordId: 'thread:a', table: 'thread', fields: ['title'], queuedAt: 1000, outcome: { status: 'synced', at: 1100 } },
+      { id: id(2000), op: 'update', recordId: 'thread:b', table: 'thread', fields: ['body'], queuedAt: 2000, outcome: { status: 'rolled-back', at: 2100, error: 'denied' } },
+      { id: id(3000), op: 'update', recordId: 'thread:c', table: 'thread', fields: ['x'], queuedAt: 3000 },
+      { id: id(4000), op: 'delete', recordId: 'thread:d', table: 'thread', queuedAt: 4000 },
+    ];
+    const s = build({ history, outbox: [item({ id: id(3000), recordId: 'thread:c', attempts: 1 })] });
+    const byId = new Map(s.entries.map((e) => [e.id, e]));
+    expect(byId.get(id(1000))).toMatchObject({ status: 'synced', settledAt: 1100, fields: ['title'] });
+    expect(byId.get(id(2000))).toMatchObject({ status: 'rolled-back', error: 'denied' });
+    expect(byId.get(id(3000))).toMatchObject({ status: 'retrying', attempts: 1, fields: ['x'] });
+    expect(byId.get(id(4000))).toMatchObject({ status: 'dropped' });
+  });
+
+  it('caps entries but counts and totals everything', () => {
+    const outbox = Array.from({ length: 5 }, (_, i) => item({ id: id(1000 + i) }));
+    const s = build({ outbox, cap: 2 });
+    expect(s.entries.map((e) => e.queuedAt)).toEqual([1004, 1003]);
+    expect(s.total).toBe(5);
+    expect(s.counts.pending).toBe(5);
+  });
+
+  it('lists debounced writes and carries role, health and tray count', () => {
+    const w: PendingWrite = { key: 'k', table: 'doc', recordId: 'doc:1', data: { title: 't', body: 'b' }, before: null, firstAt: 42, mirrorId: null };
+    const s = build({
+      pendingWrites: [w],
+      failedCount: 3,
+      tabRole: 'follower',
+      health: { ...initialHealth('reconnecting'), status: 'degraded', consecutiveFailures: 4, error: 'socket closed' },
+    });
+    expect(s.debounced).toEqual([{ key: 'k', recordId: 'doc:1', table: 'doc', fields: ['title', 'body'], since: 42, durable: false }]);
+    expect(s).toMatchObject({ role: 'follower', connection: 'reconnecting', health: 'degraded', consecutiveFailures: 4, lastError: 'socket closed' });
+    expect(s.counts).toMatchObject({ failed: 3, debounced: 1 });
+  });
+});
+
+describe('trimHistory', () => {
+  it('drops the oldest entries first', () => {
+    const h = new Map<string, MutationHistoryEntry>();
+    for (const n of [1, 2, 3]) h.set(`m${n}`, { id: `m${n}`, op: 'create', recordId: 'a:1', table: 'a', queuedAt: n });
+    trimHistory(h, 2);
+    expect([...h.keys()]).toEqual(['m2', 'm3']);
+  });
+});

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

@@ -0,0 +1,166 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { RecordId } from 'surrealdb';
+import { DevToolsService } from './index';
+
+/**
+ * A state push serializes EVERY active query's full record set and postMessage
+ * clones it again, so its cost scales with the whole client dataset. It is
+ * 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. `onStateChanged` stands in for any trigger.
+ */
+
+function harness(recordCount = 500) {
+  const posted: any[] = [];
+  const listeners: ((e: any) => void)[] = [];
+  const fakeWindow: any = {
+    postMessage: (msg: any) => posted.push(msg),
+    addEventListener: (_type: string, cb: (e: any) => void) => listeners.push(cb),
+    dispatchEvent: () => true,
+  };
+  fakeWindow.self = fakeWindow;
+  vi.stubGlobal('window', fakeWindow);
+  vi.stubGlobal('CustomEvent', class {
+    type: string;
+    constructor(type: string) {
+      this.type = type;
+    }
+  });
+
+  const noop = () => {};
+  const logger: any = { debug: noop, info: noop, warn: noop, error: noop, trace: noop };
+  logger.child = () => logger;
+
+  const local: any = {
+    query: async () => [],
+    getConfig: () => ({ store: 'memory' }),
+    currentBucketId: 'anon',
+    storageHealth: { status: 'memory', fallback: false },
+  };
+  const remote: any = { query: async () => [] };
+  const auth: any = {
+    isAuthenticated: false,
+    currentUser: undefined,
+    eventSystem: { subscribe: noop },
+  };
+  // One query holding a lot of rows: the thing whose repeated serialization is
+  // what actually blows the heap.
+  const records = Array.from({ length: recordCount }, (_, i) => ({ id: `game:${i}`, pgn: 'x' }));
+  const dataManager: any = {
+    getActiveQueries: () => [
+      {
+        config: { id: new RecordId('_00_query', 'q1'), params: {} },
+        status: 'idle',
+        records,
+        updateCount: 1,
+      },
+    ],
+    phaseTimings: () => ({}),
+  };
+
+  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, mutations };
+}
+
+afterEach(() => {
+  vi.useRealTimers();
+  vi.unstubAllGlobals();
+});
+
+describe('DevToolsService state-push coalescing', () => {
+  it('pushes once on connect, on the next macrotask', () => {
+    vi.useFakeTimers();
+    const { statePushes } = harness();
+    // Never inline: a push serializes the state, and the request can come
+    // from inside an ingest or a mutation the app is awaiting.
+    expect(statePushes().length).toBe(0);
+    vi.advanceTimersByTime(0);
+    expect(statePushes().length).toBe(1);
+  });
+
+  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 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);
+
+    vi.advanceTimersByTime(300);
+    expect(statePushes().length).toBe(before + 1);
+  });
+
+  it('still pushes again once the window has passed', () => {
+    vi.useFakeTimers();
+    const { service, statePushes } = harness();
+    const before = statePushes().length;
+
+    service.onStateChanged();
+    vi.advanceTimersByTime(300);
+    expect(statePushes().length).toBe(before + 1);
+
+    // A request arriving right after that flush is still inside the window, so it
+    // queues rather than pushing again...
+    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 request pushes
+    // straight away, so the panel never waits on a quiet app.
+    vi.advanceTimersByTime(1000);
+    service.onStateChanged();
+    vi.advanceTimersByTime(0);
+    expect(statePushes().length).toBe(before + 3);
+  });
+
+  it('drops a queued push when the consumer disconnects mid-window', () => {
+    vi.useFakeTimers();
+    const { service, statePushes, posted } = harness();
+    const before = statePushes().length;
+
+    service.onStateChanged();
+    (service as any).enabled = false; // panel closed while the push was queued
+    vi.advanceTimersByTime(300);
+    expect(statePushes().length).toBe(before);
+    expect(posted.some((m) => m.type === 'SP00KY_STATE_CHANGED' && m.state === undefined)).toBe(false);
+  });
+
+  it('serializes the LATEST state at flush time, not at request time', () => {
+    vi.useFakeTimers();
+    const { service, statePushes, mutations } = harness();
+    vi.advanceTimersByTime(300);
+
+    service.onStateChanged();
+    mutations.failedCount = 1;
+    service.onStateChanged();
+    mutations.failedCount = 2;
+    vi.advanceTimersByTime(300);
+
+    // 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

@@ -0,0 +1,263 @@
+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
+ * membership arrays), deep-cloned once by the serializer and again by
+ * postMessage, on every sync event, from inside the ingest call stack. On a
+ * client holding a few thousand rows that is what the main thread was doing
+ * instead of finishing the write the app was awaiting. Pushes now carry counts
+ * and capped ids; rows are pulled per view on demand.
+ */
+function harness(recordCount = 500) {
+  const posted: any[] = [];
+  const listeners: ((e: any) => void)[] = [];
+  const fakeWindow: any = {
+    postMessage: (msg: any) => posted.push(msg),
+    addEventListener: (_type: string, cb: (e: any) => void) => listeners.push(cb),
+    dispatchEvent: () => true,
+  };
+  fakeWindow.self = fakeWindow;
+  vi.stubGlobal('window', fakeWindow);
+  vi.stubGlobal('CustomEvent', class {
+    type: string;
+    constructor(type: string) {
+      this.type = type;
+    }
+  });
+  const noop = () => {};
+  const logger: any = { debug: noop, info: noop, warn: noop, error: noop, trace: noop };
+  logger.child = () => logger;
+  const infoQueries: string[] = [];
+  const local: any = {
+    query: async (sql: string) => {
+      infoQueries.push(sql);
+      return [];
+    },
+    getConfig: () => ({ store: 'memory' }),
+    currentBucketId: 'anon',
+    storageHealth: { status: 'memory', fallback: false },
+  };
+  const remote: any = { query: async () => [] };
+  const auth: any = { isAuthenticated: false, currentUser: undefined, eventSystem: { subscribe: noop } };
+  const records = Array.from({ length: recordCount }, (_, i) => ({ id: `game:${i}`, pgn: 'x' }));
+  const localArray = records.map((r) => [r.id, 1] as [string, number]);
+  const id = new RecordId('_00_query', 'q1');
+  const query = {
+    config: { id, params: {}, localArray, remoteArray: localArray, surql: 'SELECT * FROM game' },
+    status: 'idle',
+    records,
+    updateCount: 1,
+  };
+  const dataManager: any = {
+    getActiveQueries: () => [query],
+    getQueryById: (rid: RecordId<string>) => (String(rid) === String(id) ? query : undefined),
+    phaseTimings: () => ({}),
+  };
+  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, logger };
+}
+
+describe('DevTools pushed state shape', () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    vi.useRealTimers();
+  });
+
+  it('carries counts and capped ids, never the rows', async () => {
+    vi.useFakeTimers();
+    const { service, statePushes } = harness(500);
+    service.onStateChanged();
+    await vi.advanceTimersByTimeAsync(300);
+    const push = statePushes().at(-1);
+    expect(push).toBeDefined();
+    const q: any = Object.values(push.state.activeQueries)[0];
+    expect(q.data).toBeUndefined();
+    expect(q.localArray).toBeUndefined();
+    expect(q.remoteArray).toBeUndefined();
+    expect(q.dataSize).toBe(500);
+    expect(q.localCount).toBe(500);
+    expect(q.remoteCount).toBe(500);
+    expect(q.localIds).toHaveLength(200);
+    expect(q.idsTruncated).toBe(true);
+  });
+
+  it('never pushes synchronously inside the call that requested it', async () => {
+    vi.useFakeTimers();
+    const { service, statePushes } = harness(5);
+    // Connect already queued one push; drain it so the next request is "idle".
+    await vi.advanceTimersByTimeAsync(300);
+    const before = statePushes().length;
+    service.onStreamUpdate({ queryHash: 'q1', localArray: [], op: 'CREATE' });
+    expect(statePushes().length).toBe(before);
+    await vi.advanceTimersByTimeAsync(0);
+    expect(statePushes().length).toBe(before + 1);
+  });
+
+  it('serves the rows of one view on demand', () => {
+    const { service, fakeWindow } = harness(3);
+    void service;
+    const state = fakeWindow.__00__.getState();
+    const hash = Number(Object.keys(state.activeQueries)[0]);
+    const rows = fakeWindow.__00__.getQueryRows(hash);
+    expect(rows.data).toHaveLength(3);
+    expect(rows.localArray).toHaveLength(3);
+    expect(fakeWindow.__00__.getQueryRows(12345)).toBeNull();
+  });
+
+  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 () => {
+    vi.useFakeTimers();
+    const { service, statePushes } = harness(1);
+    await vi.advanceTimersByTimeAsync(300);
+    const before = statePushes().length;
+    service.onStreamUpdate({ queryHash: 'q1', localArray: [], op: 'UPDATE', synthetic: true });
+    await vi.advanceTimersByTimeAsync(300);
+    expect(statePushes().length).toBe(before);
+  });
+
+  it('refreshes the table list on an explicit pull, not on a push', async () => {
+    vi.useFakeTimers();
+    const { service, fakeWindow, infoQueries } = harness(1);
+    const connectRefreshes = infoQueries.filter((q) => q.includes('INFO FOR DB')).length;
+    for (let i = 0; i < 10; i++) {
+      service.onStreamUpdate({ queryHash: 'q1', localArray: [], op: 'UPDATE' });
+      await vi.advanceTimersByTimeAsync(300);
+    }
+    expect(infoQueries.filter((q) => q.includes('INFO FOR DB')).length).toBe(connectRefreshes);
+    vi.setSystemTime(Date.now() + 60_000);
+    fakeWindow.__00__.getState();
+    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);
+  });
+});