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/repos/in-memory.ts

@@ -0,0 +1,151 @@
+/**
+ * In-memory `Map`-backed repositories.
+ *
+ * Implements the MVP storage layer. The repository interfaces match the
+ * shape that ADR-0005's eventual persistence implementation will satisfy,
+ * so swapping `createInMemoryRepos()` for a SQLite/Postgres factory later
+ * is a localised change.
+ *
+ * All mutating methods return the *stored* object so callers can pick up
+ * server-assigned fields (none in MVP, but the contract anticipates it).
+ */
+
+import type { Annotation } from "@shared/annotation";
+import type { Document, DocumentRepresentation } from "@shared/document";
+import type { EvidenceItem } from "@shared/evidence";
+import type {
+  AnnotationId,
+  DocumentId,
+  EvidenceItemId,
+  RepresentationId,
+} from "@shared/ids";
+
+export interface DocumentRepository {
+  create(document: Document): Document;
+  get(id: DocumentId): Document | null;
+  list(): readonly Document[];
+  update(document: Document): Document;
+}
+
+export interface RepresentationRepository {
+  create(representation: DocumentRepresentation): DocumentRepresentation;
+  get(id: RepresentationId): DocumentRepresentation | null;
+  listByDocument(documentId: DocumentId): readonly DocumentRepresentation[];
+}
+
+export interface AnnotationRepository {
+  create(annotation: Annotation): Annotation;
+  get(id: AnnotationId): Annotation | null;
+  listByDocument(documentId: DocumentId): readonly Annotation[];
+  update(annotation: Annotation): Annotation;
+}
+
+export interface EvidenceItemRepository {
+  create(item: EvidenceItem): EvidenceItem;
+  get(id: EvidenceItemId): EvidenceItem | null;
+  listByDocument(
+    documentId: DocumentId,
+    annotationLookup: (id: AnnotationId) => Annotation | null,
+  ): readonly EvidenceItem[];
+  update(item: EvidenceItem): EvidenceItem;
+}
+
+export interface InMemoryRepos {
+  readonly documents: DocumentRepository;
+  readonly representations: RepresentationRepository;
+  readonly annotations: AnnotationRepository;
+  readonly evidenceItems: EvidenceItemRepository;
+}
+
+export function createInMemoryRepos(): InMemoryRepos {
+  const documents = new Map<DocumentId, Document>();
+  const representations = new Map<RepresentationId, DocumentRepresentation>();
+  const annotations = new Map<AnnotationId, Annotation>();
+  const evidenceItems = new Map<EvidenceItemId, EvidenceItem>();
+
+  return {
+    documents: {
+      create(document) {
+        documents.set(document.id, document);
+        return document;
+      },
+      get(id) {
+        return documents.get(id) ?? null;
+      },
+      list() {
+        return [...documents.values()];
+      },
+      update(document) {
+        if (!documents.has(document.id)) {
+          throw new Error(`DocumentRepository.update: unknown id ${document.id}`);
+        }
+        documents.set(document.id, document);
+        return document;
+      },
+    },
+    representations: {
+      create(representation) {
+        representations.set(representation.id, representation);
+        return representation;
+      },
+      get(id) {
+        return representations.get(id) ?? null;
+      },
+      listByDocument(documentId) {
+        const out: DocumentRepresentation[] = [];
+        for (const rep of representations.values()) {
+          if (rep.documentId === documentId) out.push(rep);
+        }
+        return out;
+      },
+    },
+    annotations: {
+      create(annotation) {
+        annotations.set(annotation.id, annotation);
+        return annotation;
+      },
+      get(id) {
+        return annotations.get(id) ?? null;
+      },
+      listByDocument(documentId) {
+        const out: Annotation[] = [];
+        for (const ann of annotations.values()) {
+          if (ann.documentId === documentId) out.push(ann);
+        }
+        return out;
+      },
+      update(annotation) {
+        if (!annotations.has(annotation.id)) {
+          throw new Error(`AnnotationRepository.update: unknown id ${annotation.id}`);
+        }
+        annotations.set(annotation.id, annotation);
+        return annotation;
+      },
+    },
+    evidenceItems: {
+      create(item) {
+        evidenceItems.set(item.id, item);
+        return item;
+      },
+      get(id) {
+        return evidenceItems.get(id) ?? null;
+      },
+      listByDocument(documentId, annotationLookup) {
+        const out: EvidenceItem[] = [];
+        for (const item of evidenceItems.values()) {
+          if (item.annotationIds.some((aid) => annotationLookup(aid)?.documentId === documentId)) {
+            out.push(item);
+          }
+        }
+        return out;
+      },
+      update(item) {
+        if (!evidenceItems.has(item.id)) {
+          throw new Error(`EvidenceItemRepository.update: unknown id ${item.id}`);
+        }
+        evidenceItems.set(item.id, item);
+        return item;
+      },
+    },
+  };
+}