Implement CE-WP-0002 T03-T09: ingest, anchor resolution, engine, UI, persistence, e2e

Completes the PDF review slice end-to-end. After this commit a user can
open a fixture, select text, save an evidence item with commentary, see
it in the sidebar, reload the page, click the item, and the viewer
scrolls to the passage.

- T03 src/source/pdf/{fingerprint,extract,ingest}.ts + 39 fixture tests
  - SHA-256 fingerprint over a fresh ArrayBuffer (TS BufferSource-safe)
  - PDF.js text extract; per-page normalize then join with "\n\n"
  - PageMap + OffsetMap (gap-free coverage); pageLength = end - start
  - Updated manifest's Betriebskosten quote to one PDF.js extracts cleanly
- T04 src/anchor/selectors/{create,resolve}.ts + 25 unit + 7 fixture tests
  - createSelectors emits the maximal redundant set (TextQuote +
    TextPosition + PdfRect + PdfPageText when available)
  - resolveSelectors implements the SharedContracts §7 ladder; confidence
    1.0 (pos+quote) → 0.7 (rect-only) → 0 (unresolved)
  - Cross-module integration test moved to tests/integration/ to honor
    the anchor↛source boundary lint rule
- T05 engine: sync event bus over the closed §4 vocabulary, Map-backed
  repos, services, createEngine() composition root, 12 tests
- T06 work + app: three-pane shell (CollectionList | ViewerShell |
  EvidenceSidebar) wired through EngineProvider; EngineContext lives in
  src/work/ to respect the work↛app boundary; SpikeApp deleted
- T07 AnnotationToolbar: pendingSelection in context; Save runs
  createSelectors → engine.annotations.create → engine.evidence.create
- T08 click-to-reopen + localStorage persistence
  - scrollToAnnotation state in context with a version counter so a
    second click on the same item re-fires the viewer scroll
  - captureSnapshot/restoreSnapshot/attachPersister/restoreFromStorage;
    restore bypasses services to avoid event-loops
  - active-document id persisted alongside the snapshot so reload lands
    on the same fixture; ADR-0005 written
  - 9 persistence tests
- T09 tests/integration/app-prd-scenario.dom.test.tsx
  - end-to-end happy-dom test of PRD scenario steps 1-8 through the real
    React tree; viewer + ingest mocked per ADR-0004's headless-Chromium
    limitation. Fixed memo-deps bug in EvidenceSidebar/ViewerShell where
    useEngineEventTick values were not included in the useMemo deps,
    leaving stale memoization across event-driven re-renders
- vitest.config.ts: happy-dom for *.dom.test.{ts,tsx} files
- noEmit added to tsconfig so tsc -b doesn't litter src/ with .js outputs

Gates: typecheck ✓ lint ✓ test 109/109 across 11 files ✓ build ✓

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

src/engine/persistence.test.ts

@@ -0,0 +1,183 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { Document, DocumentRepresentation } from "@shared/document";
+import type { DocumentId, RepresentationId } from "@shared/ids";
+import {
+  attachPersister,
+  captureSnapshot,
+  createEngine,
+  restoreFromStorage,
+  restoreSnapshot,
+  type Engine,
+  type EngineEvent,
+  type EngineSnapshot,
+} from "./index";
+
+function fakeDocAndRep(suffix: string): {
+  document: Document;
+  representation: DocumentRepresentation;
+} {
+  const docId = `doc_${suffix}` as DocumentId;
+  const repId = `rep_${suffix}` as RepresentationId;
+  return {
+    document: {
+      id: docId,
+      mediaType: "application/pdf",
+      title: `Doc ${suffix}`,
+      createdAt: "2026-05-25T00:00:00.000Z",
+      updatedAt: "2026-05-25T00:00:00.000Z",
+    },
+    representation: {
+      id: repId,
+      documentId: docId,
+      representationType: "pdf-text",
+      contentHash: `hash-${suffix}`,
+      canonicalText: "The quick brown fox.",
+      pageMap: [{ page: 1, width: 100, height: 100 }],
+      offsetMap: [{ page: 1, globalStart: 0, globalEnd: 20, pageLength: 20 }],
+      generatedAt: "2026-05-25T00:00:00.000Z",
+    },
+  };
+}
+
+function memoryStorage(): Pick<Storage, "getItem" | "setItem" | "removeItem"> {
+  const map = new Map<string, string>();
+  return {
+    getItem: (k) => map.get(k) ?? null,
+    setItem: (k, v) => void map.set(k, v),
+    removeItem: (k) => void map.delete(k),
+  };
+}
+
+function seed(engine: Engine, suffix: string) {
+  const { document, representation } = fakeDocAndRep(suffix);
+  engine.documents.register({ document, representation });
+  const ann = engine.annotations.create({
+    documentId: document.id,
+    representationId: representation.id,
+    selectors: [{ type: "TextQuoteSelector", exact: "brown fox" }],
+    quote: "brown fox",
+  });
+  const item = engine.evidence.create({
+    annotationIds: [ann.id],
+    commentary: `commentary-${suffix}`,
+  });
+  return { document, representation, ann, item };
+}
+
+describe("captureSnapshot + restoreSnapshot", () => {
+  it("round-trips documents, representations, annotations and evidence items", () => {
+    const src = createEngine();
+    const a = seed(src, "a");
+    const b = seed(src, "b");
+    const snap = captureSnapshot(src);
+    expect(snap.documents).toHaveLength(2);
+    expect(snap.representations).toHaveLength(2);
+    expect(snap.annotations).toHaveLength(2);
+    expect(snap.evidenceItems).toHaveLength(2);
+
+    const dst = createEngine();
+    restoreSnapshot(dst, snap);
+    expect(dst.documents.get(a.document.id)?.title).toBe("Doc a");
+    expect(dst.documents.get(b.document.id)?.title).toBe("Doc b");
+    expect(dst.annotations.get(a.ann.id)?.quote).toBe("brown fox");
+    expect(dst.evidence.get(a.item.id)?.commentary).toBe("commentary-a");
+  });
+
+  it("restoreSnapshot does NOT emit *Created events (events would loop the persister)", () => {
+    const src = createEngine();
+    seed(src, "x");
+    const snap = captureSnapshot(src);
+
+    const dst = createEngine();
+    const seen: EngineEvent["type"][] = [];
+    dst.bus.onAny((e) => seen.push(e.type));
+    restoreSnapshot(dst, snap);
+    expect(seen).toEqual([]);
+  });
+
+  it("rejects a snapshot with a mismatching version", () => {
+    const dst = createEngine();
+    expect(() =>
+      restoreSnapshot(dst, {
+        version: 999,
+        documents: [],
+        representations: [],
+        annotations: [],
+        evidenceItems: [],
+      } as EngineSnapshot),
+    ).toThrow(/version/);
+  });
+});
+
+describe("attachPersister", () => {
+  let storage: ReturnType<typeof memoryStorage>;
+  let engine: Engine;
+  const KEY = "ce-test-snap";
+
+  beforeEach(() => {
+    storage = memoryStorage();
+    engine = createEngine();
+  });
+
+  it("writes a snapshot to storage on every mutating event", () => {
+    const off = attachPersister(engine, { key: KEY, storage });
+    expect(storage.getItem(KEY)).toBeNull();
+    seed(engine, "z");
+    const raw = storage.getItem(KEY);
+    expect(raw).not.toBeNull();
+    const snap = JSON.parse(raw!) as EngineSnapshot;
+    expect(snap.documents).toHaveLength(1);
+    expect(snap.evidenceItems).toHaveLength(1);
+    off();
+  });
+
+  it("stops writing after the unsubscribe is called", () => {
+    const off = attachPersister(engine, { key: KEY, storage });
+    seed(engine, "q");
+    const after = storage.getItem(KEY);
+    off();
+    seed(engine, "r");
+    expect(storage.getItem(KEY)).toBe(after);
+  });
+
+  it("survives a JSON.stringify failure without throwing into the caller", () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const failing = { ...memoryStorage(), setItem: () => { throw new Error("boom"); } };
+    attachPersister(engine, { key: KEY, storage: failing });
+    expect(() => seed(engine, "k")).not.toThrow();
+    expect(warn).toHaveBeenCalled();
+    warn.mockRestore();
+  });
+});
+
+describe("restoreFromStorage", () => {
+  it("returns {restored: false} when the key is empty", () => {
+    const storage = memoryStorage();
+    const engine = createEngine();
+    const result = restoreFromStorage(engine, { key: "missing", storage });
+    expect(result.restored).toBe(false);
+  });
+
+  it("hydrates the engine when storage holds a valid snapshot", () => {
+    const src = createEngine();
+    seed(src, "rs");
+    const storage = memoryStorage();
+    storage.setItem("snap", JSON.stringify(captureSnapshot(src)));
+
+    const dst = createEngine();
+    const result = restoreFromStorage(dst, { key: "snap", storage });
+    expect(result.restored).toBe(true);
+    expect(dst.documents.list()).toHaveLength(1);
+  });
+
+  it("ignores malformed JSON without throwing", () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    const storage = memoryStorage();
+    storage.setItem("snap", "not-json");
+    const engine = createEngine();
+    const result = restoreFromStorage(engine, { key: "snap", storage });
+    expect(result.restored).toBe(false);
+    expect(warn).toHaveBeenCalled();
+    warn.mockRestore();
+  });
+});