feat: implement persistence manager and cursor update handling

TODO.txt

···
 N1. Define the StatusBar view model (core, pure TS)
 ------------------------------------------------------------------------------
 
-/packages/core/src/ui/statusbar/types.ts
-[ ] Define StatusBarVM (single object the UI renders):
+/packages/core/src/ui/statusbar.ts
+[x] Define StatusBarVM (single object the UI renders):
     - cursorWorld: { x, y }         " world coords (always)
     - cursorScreen: { x, y }?       " optional dev-only
     - zoomPct: number               " e.g. 100, 67, 250
···
 N2. Provide selectors / derivations for StatusBarVM
 ------------------------------------------------------------------------------
 
-/packages/core/src/ui/statusbar/selectors.ts
-[ ] Implement pure functions:
+/packages/core/src/ui/statusbar.ts
+[x] Implement pure functions:
     - getZoomPct(state) -> number
     - getToolId(state) -> ToolId
     - getSelectionSummary(state) -> { count, kind?, bounds? }
     - getSnapSummary(state) -> snap summary (default safe values)
 
 Cursor position source:
-[ ] Define a minimal CursorState in core (NOT persisted):
+[x] Define a minimal CursorState in core (NOT persisted):
     - cursorWorld: Vec2
     - cursorScreen?: Vec2
     - lastMoveAt: number
 
-[ ] Add updateCursor(world, screen?) action + reducer handler (or direct setter)
+[x] Add updateCursor(world, screen?) action + reducer handler (or direct setter)
     that ONLY touches CursorState (no history command, no persistence).
 
 (DoD):
···
 N3. Wire cursor updates from pointer movement (apps/web)
 ------------------------------------------------------------------------------
 
-/apps/web/src/lib/pointer.ts
-[ ] On pointermove (or mousemove when not captured):
+/apps/web/src/lib/input.ts
+[x] On pointermove (or mousemove when not captured):
     - compute world coords using camera.screenToWorld
     - dispatch updateCursor(world, screen)
 
 Performance:
-[ ] Throttle cursor updates:
+[x] Throttle cursor updates:
     - v0: requestAnimationFrame coalescing (only publish latest per frame)
     - avoid flooding render/history/persistence
 
···
 done; persistence is already hooked to history in Milestone M).
 
 /apps/web/src/lib/status.ts
-[ ] Extend your persistence sink (from Milestone M) to expose a small status:
+[x] Extend your persistence sink (from Milestone M) to expose a small status:
     - pendingWrites counter (increment on enqueue, decrement on commit)
     - lastSavedAt timestamp (set on successful commit)
     - lastError (set on failed commit)
-[ ] Use Dexie liveQuery to observe the current board’s updatedAt from IndexedDB
+[x] Use Dexie liveQuery to observe the current board’s updatedAt from IndexedDB
     and reflect it in the UI (helps confirm persisted state across tabs).
 
 (DoD):

apps/web/src/lib/canvas/Canvas.svelte

···
 	import HistoryViewer from '$lib/components/HistoryViewer.svelte';
 	import Toolbar from '$lib/components/Toolbar.svelte';
 	import { createInputAdapter, type InputAdapter } from '$lib/input';
+	import { createPersistenceManager } from '$lib/status';
 	import {
 		ArrowTool,
+		CursorStore,
 		EditorState,
 		EllipseTool,
 		InkfiniteDB,
···
 		SnapshotCommand,
 		Store,
 		TextTool,
-		createPersistenceSink,
 		createToolMap,
 		createWebDocRepo,
 		diffDoc,
···
 		type Action,
 		type CommandKind,
 		type LoadedDoc,
+		type PersistenceSink,
 		type ToolId,
 		type Viewport
 	} from 'inkfinite-core';
···
 	import { onDestroy, onMount } from 'svelte';
 
 	let repo: ReturnType<typeof createWebDocRepo> | null = null;
-	let sink: ReturnType<typeof createPersistenceSink> | null = null;
+	let sink: PersistenceSink | null = null;
+	let persistenceManager: ReturnType<typeof createPersistenceManager> | null = null;
 	let activeBoardId: string | null = null;
 
 	const store = new Store(undefined, {
···
 			sink.enqueueDocPatch(activeBoardId, patch);
 		}
 	});
+	const cursorStore = new CursorStore();
 
 	function applyLoadedDoc(doc: LoadedDoc) {
 		const firstPageId = doc.order.pageIds[0] ?? Object.keys(doc.pages)[0] ?? null;
···
 	onMount(() => {
 		const db = new InkfiniteDB();
 		repo = createWebDocRepo(db);
-		sink = createPersistenceSink(repo, { debounceMs: 200 });
+		persistenceManager = createPersistenceManager(db, repo, { sink: { debounceMs: 200 } });
+		sink = persistenceManager.sink;
 		let disposed = false;
 
 		const hydrate = async () => {
···
 				activeBoardId = id;
 				const loaded = await repoInstance.loadDoc(id);
 				if (!disposed) {
+					persistenceManager?.setActiveBoard(id);
 					applyLoadedDoc(loaded);
 				}
 			} catch (error) {
···
 		}
 
 		renderer = createRenderer(canvas, store);
-		inputAdapter = createInputAdapter({ canvas, getCamera, getViewport, onAction: handleAction });
+		inputAdapter = createInputAdapter({
+			canvas,
+			getCamera,
+			getViewport,
+			onAction: handleAction,
+			onCursorUpdate: (world, screen) => cursorStore.updateCursor(world, screen)
+		});
 
 		function handleBeforeUnload() {
 			if (sink) {
···
 		repo = null;
 		sink = null;
 		activeBoardId = null;
+		persistenceManager?.dispose();
+		persistenceManager = null;
 	});
 </script>
 

apps/web/src/lib/input.ts

···
-import { Action, type Action as ActionType, Camera, Modifiers, PointerButtons, type Viewport } from "inkfinite-core";
+import {
+  Action,
+  type Action as ActionType,
+  Camera,
+  Modifiers,
+  PointerButtons,
+  type Vec2,
+  type Viewport,
+} from "inkfinite-core";
 
 /**
  * Pointer state tracked by the input adapter
···
   getViewport: () => Viewport;
   /** Callback for dispatching actions */
   onAction: (action: ActionType) => void;
+  /** Optional callback for raw cursor updates */
+  onCursorUpdate?: (world: Vec2, screen: Vec2) => void;
   /** Whether to prevent default browser behavior (default: true) */
   preventDefault?: boolean;
   /** Whether to capture keyboard events on window (default: true) */
···
  * - Dispatches normalized actions
  */
 export class InputAdapter {
-  private config: Required<InputAdapterConfig>;
+  private config: InputAdapterConfig & { preventDefault: boolean; captureKeyboard: boolean };
   private pointerState: PointerState;
   private boundHandlers: {
     pointerDown: (e: PointerEvent) => void;
···
     keyUp: (e: KeyboardEvent) => void;
     contextMenu: (e: Event) => void;
   };
+  private cursorUpdateFrame: number | null;
+  private pendingCursorWorld: Vec2 | null;
+  private pendingCursorScreen: Vec2 | null;
 
   constructor(config: InputAdapterConfig) {
     this.config = {
···
       keyUp: this.handleKeyUp.bind(this),
       contextMenu: this.handleContextMenu.bind(this),
     };
+    this.cursorUpdateFrame = null;
+    this.pendingCursorWorld = null;
+    this.pendingCursorScreen = null;
 
     this.attach();
   }
···
       window.removeEventListener("keydown", this.boundHandlers.keyDown);
       window.removeEventListener("keyup", this.boundHandlers.keyUp);
     }
+
+    if (
+      this.cursorUpdateFrame !== null
+      && typeof window !== "undefined"
+      && typeof window.cancelAnimationFrame === "function"
+    ) {
+      window.cancelAnimationFrame(this.cursorUpdateFrame);
+      this.cursorUpdateFrame = null;
+    }
   }
 
   /**
···
     this.pointerState.buttons = buttons;
 
     this.config.onAction(Action.pointerMove(screen, world, buttons, modifiers));
+    this.queueCursorUpdate(world, screen);
   }
 
   /**
···
     this.config.onAction(Action.wheel(screen, world, e.deltaY, modifiers));
   }
 
-  /**
-   * Handle key down event
-   */
   private handleKeyDown(e: KeyboardEvent): void {
     const target = e.target as HTMLElement;
     if (target?.tagName === "INPUT" || target?.tagName === "TEXTAREA" || target?.isContentEditable) {
···
     }
   }
 
-  /**
-   * Handle key up event
-   */
   private handleKeyUp(e: KeyboardEvent): void {
     const target = e.target as HTMLElement;
     if (target?.tagName === "INPUT" || target?.tagName === "TEXTAREA" || target?.isContentEditable) {
···
     this.config.onAction(Action.keyUp(e.key, e.code, modifiers));
   }
 
-  /**
-   * Handle context menu event (prevent default)
-   */
   private handleContextMenu(e: Event): void {
     if (this.config.preventDefault) {
       e.preventDefault();
     }
+  }
+
+  /**
+   * Throttle cursor updates using requestAnimationFrame.
+   */
+  private queueCursorUpdate(world: Vec2, screen: Vec2): void {
+    if (!this.config.onCursorUpdate) {
+      return;
+    }
+
+    this.pendingCursorWorld = { x: world.x, y: world.y };
+    this.pendingCursorScreen = { x: screen.x, y: screen.y };
+
+    if (this.cursorUpdateFrame !== null) {
+      return;
+    }
+
+    const schedule = typeof window !== "undefined" && typeof window.requestAnimationFrame === "function"
+      ? window.requestAnimationFrame.bind(window)
+      : null;
+
+    if (!schedule) {
+      this.flushCursorUpdate();
+      return;
+    }
+
+    this.cursorUpdateFrame = schedule(() => {
+      this.cursorUpdateFrame = null;
+      this.flushCursorUpdate();
+    });
+  }
+
+  private flushCursorUpdate(): void {
+    if (!this.config.onCursorUpdate || !this.pendingCursorWorld || !this.pendingCursorScreen) {
+      this.pendingCursorWorld = null;
+      this.pendingCursorScreen = null;
+      return;
+    }
+
+    this.config.onCursorUpdate(this.pendingCursorWorld, this.pendingCursorScreen);
+    this.pendingCursorWorld = null;
+    this.pendingCursorScreen = null;
   }
 
   /**

apps/web/src/lib/status.ts

···
+import { liveQuery } from "dexie";
+import {
+  createPersistenceSink,
+  type DocPatch,
+  type DocRepo,
+  type PersistenceSink,
+  type PersistenceSinkOptions,
+} from "inkfinite-core";
+import type { InkfiniteDB, PersistenceStatus } from "inkfinite-core";
+
+type StatusListener = (status: PersistenceStatus) => void;
+
+export type StatusStore = {
+  get(): PersistenceStatus;
+  subscribe(listener: StatusListener): () => void;
+  update(updater: (status: PersistenceStatus) => PersistenceStatus): void;
+};
+
+type LiveQueryFactory = typeof liveQuery;
+
+export type PersistenceManagerOptions = { sink?: PersistenceSinkOptions; liveQueryFn?: LiveQueryFactory };
+
+export type PersistenceManager = {
+  sink: PersistenceSink;
+  status: StatusStore;
+  setActiveBoard(boardId: string | null): void;
+  dispose(): void;
+};
+
+export function createPersistenceManager(
+  db: InkfiniteDB,
+  repo: DocRepo,
+  options?: PersistenceManagerOptions,
+): PersistenceManager {
+  const sink = createPersistenceSink(repo, options?.sink);
+  const status = createStatusStore({ backend: "indexeddb", state: "saved", pendingWrites: 0 });
+
+  let activeBoardId: string | null = null;
+  let subscription: { unsubscribe(): void } | null = null;
+  const liveQueryFactory = options?.liveQueryFn ?? liveQuery;
+
+  function incrementPending() {
+    status.update((current) => ({
+      ...current,
+      pendingWrites: (current.pendingWrites ?? 0) + 1,
+      state: "saving",
+      lastError: undefined,
+    }));
+  }
+
+  function markSaved(timestamp?: number) {
+    status.update((current) => ({
+      ...current,
+      pendingWrites: 0,
+      state: "saved",
+      lastSavedAt: timestamp ?? current.lastSavedAt,
+      errorMsg: undefined,
+    }));
+  }
+
+  function markError(error: unknown) {
+    status.update((current) => ({
+      ...current,
+      state: "error",
+      errorMsg: error instanceof Error ? error.message : String(error),
+    }));
+  }
+
+  function setActiveBoard(boardId: string | null) {
+    if (activeBoardId === boardId) {
+      return;
+    }
+
+    subscription?.unsubscribe();
+    subscription = null;
+    activeBoardId = boardId;
+
+    if (!boardId) {
+      return;
+    }
+
+    const observable = liveQueryFactory(() => db.boards.get(boardId));
+    subscription = observable.subscribe({
+      next(board) {
+        if (board?.updatedAt !== undefined) {
+          markSaved(board.updatedAt);
+        }
+      },
+      error(err) {
+        markError(err);
+      },
+    });
+  }
+
+  const trackedSink: PersistenceSink = {
+    enqueueDocPatch(boardId, patch) {
+      if (hasPatchChanges(patch)) {
+        incrementPending();
+      }
+      sink.enqueueDocPatch(boardId, patch);
+    },
+    async flush() {
+      try {
+        await sink.flush();
+      } catch (error) {
+        markError(error);
+        throw error;
+      }
+    },
+  };
+
+  return {
+    sink: trackedSink,
+    status,
+    setActiveBoard,
+    dispose() {
+      subscription?.unsubscribe();
+      subscription = null;
+    },
+  };
+}
+
+function createStatusStore(initial: PersistenceStatus): StatusStore {
+  let value = initial;
+  const listeners = new Set<StatusListener>();
+
+  return {
+    get() {
+      return value;
+    },
+    subscribe(listener: StatusListener) {
+      listeners.add(listener);
+      listener(value);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    update(updater) {
+      value = updater(value);
+      for (const listener of listeners) {
+        listener(value);
+      }
+    },
+  };
+}
+
+function hasPatchChanges(patch: DocPatch): boolean {
+  const upserts = patch.upserts;
+  if (upserts?.pages?.length || upserts?.shapes?.length || upserts?.bindings?.length) {
+    return true;
+  }
+
+  const deletes = patch.deletes;
+  if (deletes?.pageIds?.length || deletes?.shapeIds?.length || deletes?.bindingIds?.length) {
+    return true;
+  }
+
+  if (patch.order) {
+    if (patch.order.pageIds?.length) {
+      return true;
+    }
+    if (patch.order.shapeOrder && Object.keys(patch.order.shapeOrder).length > 0) {
+      return true;
+    }
+  }
+
+  return false;
+}

apps/web/src/lib/tests/Canvas.history.test.ts

···
 
 const actionHandlers: Array<(action: any) => void> = [];
 const coreMocks = vi.hoisted(() => ({ sinkEnqueueSpy: vi.fn(), storeInstances: [] as any[] }));
+const persistenceMocks = vi.hoisted(() => {
+  const state = {
+    instance: null as null | {
+      sink: { enqueueDocPatch: ReturnType<typeof vi.fn>; flush: ReturnType<typeof vi.fn> };
+      status: {
+        get: () => { backend: string; state: string; pendingWrites: number };
+        subscribe: () => () => void;
+        update: () => void;
+      };
+      setActiveBoard: ReturnType<typeof vi.fn>;
+      dispose: ReturnType<typeof vi.fn>;
+    },
+  };
+  return {
+    state,
+    createPersistenceManager: vi.fn(() => {
+      state.instance = {
+        sink: { enqueueDocPatch: vi.fn(), flush: vi.fn() },
+        status: {
+          get: () => ({ backend: "indexeddb", state: "saved", pendingWrites: 0 }),
+          subscribe: () => () => {},
+          update: () => {},
+        },
+        setActiveBoard: vi.fn(),
+        dispose: vi.fn(),
+      };
+      return state.instance;
+    }),
+  };
+});
 
 vi.mock("../input", () => {
   return {
···
     }),
   };
 });
+
+vi.mock("$lib/status", () => ({ createPersistenceManager: persistenceMocks.createPersistenceManager }));
 
 vi.mock("inkfinite-renderer", () => {
   return { createRenderer: vi.fn(() => ({ dispose: vi.fn(), markDirty: vi.fn() })) };
···
     createToolMap: (toolList: any[]) => new Map(toolList.map((tool) => [tool.id, tool])),
     routeAction,
     switchTool: (state: any, toolId: string) => ({ ...state, ui: { ...state.ui, toolId } }),
+    CursorStore: class {
+      updateCursor() {}
+      subscribe() {
+        return () => {};
+      }
+      getState() {
+        return { cursorWorld: { x: 0, y: 0 }, lastMoveAt: Date.now() };
+      }
+    },
     createWebDocRepo,
     createPersistenceSink: vi.fn(() => ({ enqueueDocPatch: sinkEnqueueSpy, flush: vi.fn() })),
     diffDoc: vi.fn(() => ({})),
···
     const stores = (InkfiniteCore as any).__storeInstances as Array<{ commands: any[] }>;
     expect(stores.at(-1)?.commands).toHaveLength(1);
     expect(stores.at(-1)?.commands[0].kind).toBe("doc");
-    const sinkSpy = (InkfiniteCore as any).__sinkEnqueueSpy as ReturnType<typeof vi.fn>;
-    expect(sinkSpy).toHaveBeenCalledTimes(1);
+    expect(persistenceMocks.state.instance?.sink.enqueueDocPatch).toHaveBeenCalledTimes(1);
   });
 });

apps/web/src/lib/tests/Canvas.svelte.test.ts

···
-import { beforeEach, describe, expect, it } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import { cleanup, render } from "vitest-browser-svelte";
 import Canvas from "../canvas/Canvas.svelte";
+
+vi.mock("$lib/status", () => {
+  return {
+    createPersistenceManager: () => ({
+      sink: {
+        enqueueDocPatch: () => {},
+        flush: () => Promise.resolve(),
+      },
+      status: {
+        get: () => ({ backend: "indexeddb", state: "saved", pendingWrites: 0 }),
+        subscribe: () => () => {},
+        update: () => {},
+      },
+      setActiveBoard: () => {},
+      dispose: () => {},
+    }),
+  };
+});
 
 describe("Canvas component", () => {
   beforeEach(() => {

apps/web/src/lib/tests/input.test.ts

···
     });
   });
 
+  describe("cursor updates", () => {
+    it("throttles onCursorUpdate via requestAnimationFrame", () => {
+      adapter.dispose();
+      const rafCallbacks: FrameRequestCallback[] = [];
+      const rafSpy = vi.spyOn(window, "requestAnimationFrame").mockImplementation((cb: FrameRequestCallback) => {
+        rafCallbacks.push(cb);
+        return rafCallbacks.length;
+      });
+      const cancelSpy = vi.spyOn(window, "cancelAnimationFrame").mockImplementation(() => {});
+      const onCursorUpdate = vi.fn();
+
+      adapter = new InputAdapter({
+        canvas,
+        getCamera: () => camera,
+        getViewport: () => ({ width: 800, height: 600 }),
+        onAction: (action) => actions.push(action),
+        onCursorUpdate,
+      });
+
+      canvas.dispatchEvent(createPointerEvent("pointermove", { clientX: 10, clientY: 20 }));
+      canvas.dispatchEvent(createPointerEvent("pointermove", { clientX: 50, clientY: 60 }));
+
+      expect(onCursorUpdate).not.toHaveBeenCalled();
+      expect(rafCallbacks).toHaveLength(1);
+
+      rafCallbacks[0](16);
+
+      expect(onCursorUpdate).toHaveBeenCalledTimes(1);
+      expect(onCursorUpdate).toHaveBeenCalledWith({ x: -350, y: -240 }, { x: 50, y: 60 });
+
+      rafSpy.mockRestore();
+      cancelSpy.mockRestore();
+    });
+  });
+
   describe("wheel events", () => {
     it("should dispatch wheel action", () => {
       const event = createWheelEvent({ clientX: 400, clientY: 300, deltaY: -100 });

apps/web/src/lib/tests/status.test.ts

···
+import type { Observable, Observer, Subscription } from "dexie";
+import type { DocPatch, DocRepo, InkfiniteDB, PageRecord } from "inkfinite-core";
+import { describe, expect, it, vi } from "vitest";
+import { createPersistenceManager, type PersistenceManagerOptions } from "../status";
+
+function createMockRepo(): DocRepo {
+  return {
+    listBoards: vi.fn(async () => []),
+    createBoard: vi.fn(async () => "board:mock"),
+    renameBoard: vi.fn(async () => {}),
+    deleteBoard: vi.fn(async () => {}),
+    loadDoc: vi.fn(async () => ({ pages: {}, shapes: {}, bindings: {}, order: { pageIds: [], shapeOrder: {} } })),
+    applyDocPatch: vi.fn(async () => {}),
+    exportBoard: vi.fn(async () => ({
+      board: { id: "board:mock", name: "", createdAt: 0, updatedAt: 0 },
+      doc: { pages: {}, shapes: {}, bindings: {} },
+      order: { pageIds: [], shapeOrder: {} },
+    })),
+    importBoard: vi.fn(async () => "board:mock"),
+  };
+}
+
+type ObserverLike = { next: (value: any) => void; error?: (err: unknown) => void };
+
+function createMockLiveQuery() {
+  const observers = new Set<ObserverLike>();
+  const factory: PersistenceManagerOptions["liveQueryFn"] = () => {
+    const observable: Observable<any> = {
+      subscribe(observer?: Observer<any> | ((value: any) => void) | null) {
+        const normalized: ObserverLike = typeof observer === "function"
+          ? { next: observer }
+          : observer
+          ? { next: observer.next ?? (() => {}), error: observer.error }
+          : { next: () => {} };
+        observers.add(normalized);
+        const subscription = {
+          closed: false,
+          unsubscribe() {
+            if (subscription.closed) {
+              return;
+            }
+            subscription.closed = true;
+            observers.delete(normalized);
+          },
+        };
+        return subscription as Subscription;
+      },
+      [Symbol.observable]() {
+        return this;
+      },
+    };
+    return observable;
+  };
+
+  return {
+    factory,
+    emit(value: any) {
+      for (const observer of observers) {
+        observer.next(value);
+      }
+    },
+    error(err: unknown) {
+      for (const observer of observers) {
+        observer.error?.(err);
+      }
+    },
+    observerCount() {
+      return observers.size;
+    },
+  };
+}
+
+function createStatusTracker(
+  overrides?: { repo?: DocRepo; options?: PersistenceManagerOptions; db?: Partial<InkfiniteDB> },
+) {
+  const repo = overrides?.repo ?? createMockRepo();
+  const live = overrides?.options?.liveQueryFn ? null : createMockLiveQuery();
+  const options: PersistenceManagerOptions = overrides?.options ?? { liveQueryFn: live?.factory };
+  const db = (overrides?.db ?? { boards: { get: vi.fn(async () => undefined) } }) as InkfiniteDB;
+  const manager = createPersistenceManager(db, repo, options);
+  const mock = { repo, live, manager };
+  return mock;
+}
+
+function buildPatch(): DocPatch {
+  return { upserts: { pages: [{ id: "page:1", name: "Page 1", shapeIds: [] } as PageRecord] } };
+}
+
+describe("createPersistenceManager", () => {
+  it("tracks pending writes and resets when liveQuery emits", () => {
+    const { live, manager } = createStatusTracker();
+    expect(manager.status.get().pendingWrites).toBe(0);
+    manager.setActiveBoard("board:1");
+
+    manager.sink.enqueueDocPatch("board:1", buildPatch());
+    let status = manager.status.get();
+    expect(status.state).toBe("saving");
+    expect(status.pendingWrites).toBe(1);
+
+    live?.emit({ updatedAt: 123 });
+    status = manager.status.get();
+    expect(status.pendingWrites).toBe(0);
+    expect(status.state).toBe("saved");
+    expect(status.lastSavedAt).toBe(123);
+  });
+
+  it("records errors from flush", async () => {
+    const repo = createMockRepo();
+    (repo.applyDocPatch as ReturnType<typeof vi.fn>).mockRejectedValueOnce(new Error("failed"));
+    const { manager } = createStatusTracker({ repo });
+    manager.setActiveBoard("board:1");
+    manager.sink.enqueueDocPatch("board:1", buildPatch());
+
+    await expect(manager.sink.flush()).rejects.toThrow("failed");
+    expect(manager.status.get().state).toBe("error");
+    expect(manager.status.get().errorMsg).toBe("failed");
+  });
+
+  it("stops liveQuery when disposed", () => {
+    const live = createMockLiveQuery();
+    const { manager } = createStatusTracker({ options: { liveQueryFn: live.factory } });
+    manager.setActiveBoard("board:1");
+    expect(live.observerCount()).toBe(1);
+    manager.dispose();
+    expect(live.observerCount()).toBe(0);
+  });
+});