feat(editor): M1 pdfrx spike + pen/touch capture

Add pdfrx 2.4.4. PenCaptureRegion routes stylus to ink (arena-bypass
via PenCaptureBinding) while touch falls through to pdfrx scroll/zoom.
Spike pane hosts PdfViewer with page-overlay ink at normalized coords +
frame-time HUD; reachable from home screen for on-device testing.
Bench/coordinate harness under integration_test. Generated assets are
gitignored (regenerate via tool/gen_*.dart).

lib/editor/pdf/spike_editor_pane.dart

@@ -0,0 +1,344 @@
+// lib/editor/pdf/spike_editor_pane.dart
+//
+// THROWAWAY M1 spike widget (plan §10 / MUST #2, #4, #5). Hosts a pdfrx
+// PdfViewer.file and exercises the three things the M1 gate must prove:
+//
+//  1. Coordinate correctness (MUST #2): a `pageOverlaysBuilder` paints a
+//     diagnostic crosshair at normalized (0.5, 0.5) using
+//     `canvas.scale(size.width, size.height)`, with the CustomPaint sized to
+//     `pageRect.size` (plan §2.1). This dot MUST sit at the visual page center
+//     at every zoom level. `coordinate_assertion_test.dart` asserts this.
+//
+//  2. Pen/touch arbitration (MUST #3): a `viewerOverlayBuilder` wraps a
+//     `PenCaptureRegion` so pen events draw a live viewer-level stroke while
+//     touch scrolls and pinch zooms — same overlay, no mode switch.
+//
+//  3. Ink-overlay build cost (MUST #5): a toggle injects ~N synthetic strokes
+//     per page (from dense_strokes.json) into the page overlay so the perf
+//     bench can measure BUILD time with a non-trivial ui.Picture per page.
+//
+// This file is NOT production code and is excluded from the real editor.
+
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:flutter/material.dart';
+import 'package:pdfrx/pdfrx.dart';
+
+import 'pen_capture_region.dart';
+
+/// Normalized page-space point the diagnostic marker is painted at. The M1
+/// coordinate assertion checks this maps to the page-center pixel at all zooms.
+const Offset kMarkerNormalized = Offset(0.5, 0.5);
+
+/// A single captured pen sample in normalized page space, tagged with its page.
+class _PenSample {
+  const _PenSample(this.pageIndex, this.normalized);
+  final int pageIndex;
+  final Offset normalized;
+}
+
+/// Spike editor pane. Provide a [pdfPath] to a local PDF (e.g.
+/// test/assets/large_300p.pdf). [denseStrokesAsset] is a filesystem PATH to the
+/// synthetic ink load (MUST #5); if null the ink-load toggle is inert.
+class SpikeEditorPane extends StatefulWidget {
+  const SpikeEditorPane({
+    super.key,
+    required this.pdfPath,
+    this.denseStrokesAsset,
+    this.strokesPerPage = 300,
+    this.strokeCountKey = '2000',
+    this.onViewerReady,
+    this.controller,
+  });
+
+  final String pdfPath;
+  final String? denseStrokesAsset;
+  final int strokesPerPage;
+
+  /// Which top-level array in dense_strokes.json to draw from ("2000"/"5000").
+  final String strokeCountKey;
+
+  /// Forwarded from pdfrx once the document is laid out and interactive.
+  final void Function(PdfDocument document, PdfViewerController controller)?
+      onViewerReady;
+
+  /// Optional externally-owned controller (tests drive zoom through this).
+  final PdfViewerController? controller;
+
+  @override
+  State<SpikeEditorPane> createState() => SpikeEditorPaneState();
+}
+
+class SpikeEditorPaneState extends State<SpikeEditorPane> {
+  late final PdfViewerController _controller =
+      widget.controller ?? PdfViewerController();
+
+  /// Live pen strokes captured via PenCaptureRegion (viewer-level overlay).
+  final List<List<_PenSample>> _penStrokes = <List<_PenSample>>[];
+  List<_PenSample>? _activeStroke;
+
+  /// Synthetic strokes for the ink-load gate, lazily loaded. Each entry is a
+  /// list of normalized polylines (one stroke = list of points).
+  List<List<Offset>>? _syntheticStrokes;
+  bool _inkLoadEnabled = false;
+  bool _loadingSynthetic = false;
+
+  bool get inkLoadEnabled => _inkLoadEnabled;
+
+  /// Toggle the dense synthetic-ink overlay (MUST #5). Loads the asset on first
+  /// enable. Public so the perf bench can drive it programmatically.
+  Future<void> setInkLoad(bool enabled) async {
+    if (enabled && _syntheticStrokes == null) {
+      await _loadSyntheticStrokes();
+    }
+    if (mounted) setState(() => _inkLoadEnabled = enabled);
+  }
+
+  Future<void> _loadSyntheticStrokes() async {
+    final asset = widget.denseStrokesAsset;
+    if (asset == null || _loadingSynthetic) return;
+    _loadingSynthetic = true;
+    try {
+      // [asset] is a filesystem path (e.g. test/assets/dense_strokes.json),
+      // not a bundled rootBundle key — regenerate via tool/gen_dense_strokes.dart.
+      final raw = await File(asset).readAsString();
+      final decoded = jsonDecode(raw) as Map<String, dynamic>;
+      final strokesJson =
+          (decoded[widget.strokeCountKey] as List<dynamic>? ?? const []);
+      final result = <List<Offset>>[];
+      for (final s in strokesJson) {
+        final points = (s as Map<String, dynamic>)['points'] as List<dynamic>;
+        final poly = <Offset>[];
+        for (final p in points) {
+          final pt = p as Map<String, dynamic>;
+          poly.add(Offset(
+            (pt['x'] as num).toDouble(),
+            (pt['y'] as num).toDouble(),
+          ));
+        }
+        if (poly.length >= 2) result.add(poly);
+      }
+      _syntheticStrokes = result;
+    } finally {
+      _loadingSynthetic = false;
+    }
+  }
+
+  // --- Pen capture (viewer-level) ---------------------------------------
+
+  void _onPenEvent(PointerEvent event) {
+    // Convert global → document → which page + normalized page coords.
+    final doc = _controller.globalToDocument(event.position);
+    if (doc == null) return;
+    final hit = _documentToPage(doc);
+    if (hit == null) return;
+
+    if (event is PointerDownEvent) {
+      _activeStroke = <_PenSample>[hit];
+      _penStrokes.add(_activeStroke!);
+      setState(() {});
+    } else if (event is PointerMoveEvent) {
+      _activeStroke?.add(hit);
+      setState(() {});
+    } else if (event is PointerUpEvent || event is PointerCancelEvent) {
+      _activeStroke = null;
+    }
+  }
+
+  /// Maps a document-space point to (pageIndex, normalized-in-page) using the
+  /// controller's page layout rects (document coordinates). Returns null if the
+  /// point is outside every page box.
+  _PenSample? _documentToPage(Offset doc) {
+    if (!_controller.isReady) return null;
+    final rects = _controller.layout.pageLayouts;
+    for (var i = 0; i < rects.length; i++) {
+      final r = rects[i];
+      if (r.contains(doc)) {
+        final nx = ((doc.dx - r.left) / r.width).clamp(0.0, 1.0);
+        final ny = ((doc.dy - r.top) / r.height).clamp(0.0, 1.0);
+        return _PenSample(i, Offset(nx, ny));
+      }
+    }
+    return null;
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Stack(
+      children: [
+        PdfViewer.file(
+          widget.pdfPath,
+          controller: _controller,
+          params: PdfViewerParams(
+            onViewerReady: widget.onViewerReady,
+            // (1) Per-page overlay: diagnostic center marker + optional synthetic
+            // ink. CustomPaint is sized to pageRect.size so canvas.scale maps
+            // normalized [0,1] → zoomed pixels (plan §2.1).
+            pageOverlaysBuilder: (context, pageRectInViewer, page) {
+              final pageIndex = page.pageNumber - 1;
+              return [
+                SizedBox.fromSize(
+                  size: pageRectInViewer.size,
+                  child: CustomPaint(
+                    painter: _SpikeInkPainter(
+                      synthetic:
+                          _inkLoadEnabled ? _strokesForPage(pageIndex) : null,
+                    ),
+                  ),
+                ),
+              ];
+            },
+            // (2) Viewer-level overlay: pen capture + live pen rendering. Touch
+            // falls through to pdfrx for scroll/zoom (per-kind hit-test split).
+            viewerOverlayBuilder: (context, size, handleLinkTap) {
+              return [
+                Positioned.fill(
+                  child: PenCaptureRegion(
+                    onPenEvent: _onPenEvent,
+                    child: IgnorePointer(
+                      child: CustomPaint(
+                        size: size,
+                        painter: _LivePenPainter(
+                          strokes: _penStrokes,
+                          controller: _controller,
+                        ),
+                      ),
+                    ),
+                  ),
+                ),
+              ];
+            },
+          ),
+        ),
+      ],
+    );
+  }
+
+  /// Deterministic per-page slice of the synthetic stroke pool so each page
+  /// shows ~[widget.strokesPerPage] strokes without loading 300× the data.
+  List<List<Offset>> _strokesForPage(int pageIndex) {
+    final pool = _syntheticStrokes;
+    if (pool == null || pool.isEmpty) return const [];
+    final n = widget.strokesPerPage.clamp(0, pool.length);
+    final start = (pageIndex * n) % pool.length;
+    final out = <List<Offset>>[];
+    for (var i = 0; i < n; i++) {
+      out.add(pool[(start + i) % pool.length]);
+    }
+    return out;
+  }
+
+  // Note: PdfViewerController is not a Listenable/ChangeNotifier we own a
+  // lifecycle for; pdfrx attaches/detaches it via the PdfViewer. No dispose().
+}
+
+/// Paints the diagnostic center marker (always) plus synthetic ink (when the
+/// MUST #5 load is enabled), in normalized [0,1] page space scaled to the
+/// CustomPaint size (== zoomed page box). This is what the coordinate assertion
+/// inspects.
+class _SpikeInkPainter extends CustomPainter {
+  _SpikeInkPainter({this.synthetic});
+
+  final List<List<Offset>>? synthetic;
+
+  @override
+  void paint(Canvas canvas, Size size) {
+    canvas.save();
+    // Map normalized [0,1] → zoomed pixels (plan §2.1).
+    canvas.scale(size.width, size.height);
+
+    // Synthetic ink load (MUST #5): a non-trivial set of polylines per page.
+    final syn = synthetic;
+    if (syn != null && syn.isNotEmpty) {
+      final inkPaint = Paint()
+        ..color = const Color(0x5500AAFF)
+        ..style = PaintingStyle.stroke
+        // Stroke width is in normalized units post-scale; keep it page-relative
+        // and hairline-ish so 300 strokes are visible but cheap.
+        ..strokeWidth = 0.002
+        ..strokeCap = StrokeCap.round;
+      for (final poly in syn) {
+        if (poly.length < 2) continue;
+        final path = Path()..moveTo(poly.first.dx, poly.first.dy);
+        for (var i = 1; i < poly.length; i++) {
+          path.lineTo(poly[i].dx, poly[i].dy);
+        }
+        canvas.drawPath(path, inkPaint);
+      }
+    }
+
+    canvas.restore();
+
+    // Diagnostic crosshair at normalized (0.5,0.5) — drawn in PIXEL space (after
+    // restore) so its line thickness is constant on screen and its CENTER is at
+    // exactly size.width*0.5, size.height*0.5. The coordinate assertion checks
+    // this pixel.
+    final center = Offset(
+      size.width * kMarkerNormalized.dx,
+      size.height * kMarkerNormalized.dy,
+    );
+    final markerPaint = Paint()
+      ..color = const Color(0xFFFF0066)
+      ..strokeWidth = 2.0
+      ..style = PaintingStyle.stroke;
+    const arm = 16.0;
+    canvas.drawLine(
+        center.translate(-arm, 0), center.translate(arm, 0), markerPaint);
+    canvas.drawLine(
+        center.translate(0, -arm), center.translate(0, arm), markerPaint);
+    canvas.drawCircle(center, 3.0, Paint()..color = const Color(0xFFFF0066));
+  }
+
+  @override
+  bool shouldRepaint(covariant _SpikeInkPainter oldDelegate) =>
+      oldDelegate.synthetic != synthetic;
+}
+
+/// Paints live pen strokes captured by the PenCaptureRegion. Strokes are stored
+/// in normalized page space, so for each sample we re-project page→document→
+/// local each paint via the controller (keeps strokes glued to pages under
+/// scroll/zoom — the §2.1 property, exercised at the viewer level here).
+class _LivePenPainter extends CustomPainter {
+  _LivePenPainter({required this.strokes, required this.controller})
+      : super(repaint: controller);
+
+  final List<List<_PenSample>> strokes;
+  final PdfViewerController controller;
+
+  @override
+  void paint(Canvas canvas, Size size) {
+    if (!controller.isReady) return;
+    final rects = controller.layout.pageLayouts;
+    final paint = Paint()
+      ..color = const Color(0xFF1565C0)
+      ..style = PaintingStyle.stroke
+      ..strokeWidth = 3.0
+      ..strokeCap = StrokeCap.round
+      ..strokeJoin = StrokeJoin.round;
+
+    for (final stroke in strokes) {
+      Path? path;
+      for (final s in stroke) {
+        if (s.pageIndex >= rects.length) continue;
+        final r = rects[s.pageIndex];
+        // normalized page → document
+        final docPt = Offset(
+          r.left + s.normalized.dx * r.width,
+          r.top + s.normalized.dy * r.height,
+        );
+        // document → local (viewer) coords
+        final local = controller.documentToLocal(docPt);
+        if (path == null) {
+          path = Path()..moveTo(local.dx, local.dy);
+        } else {
+          path.lineTo(local.dx, local.dy);
+        }
+      }
+      if (path != null) canvas.drawPath(path, paint);
+    }
+  }
+
+  @override
+  bool shouldRepaint(covariant _LivePenPainter oldDelegate) => true;
+}