feat(pen): pressure-responsive width, configurable thinning, native Windows pen (tilt/buttons)

W1 — Custom pen width + pressure sensitivity (Saber-style):
- Root cause of "压感没用": perfect_freehand 1.0.4 IGNORES real stylus pressure
  (hardcodes radius=size/2 when simulatePressure=false) — width never tracked pen
  force. Upgraded perfect_freehand ^1.0.0 -> ^2.0.0 (honors real pressure); migrated
  all 5 getStroke call sites to the 2.x API (PointVector / StrokeOptions / Offset).
- De-hardcoded `thinning` into `kDefaultPenThinning` (0.85), single source shared by
  the on-screen painter and the PDF export path; exposed as PenConfig.pressureSensitivity
  with a Pressure Sensitivity slider; live-applies via a config listener.

W3 — Native Windows pen plugin (tilt + barrel/eraser buttons):
- windows/runner/pen_channel.{h,cpp}: observe WM_POINTER at the TOP of MessageHandler
  (before HandleTopLevelWindowProc, which Flutter uses to consume pen events), read
  GetPointerPenInfo penFlags + tilt, stream over EventChannel('badnote/pen'); non-consuming.
- PenInputService: single latched hardware state (no Win32-pointerId<->event.pointer
  correlation); graceful no-op off-Windows.
- pen_canvas maps barrel/inverted/eraser through PenConfig.sideButton/eraserEnd
  (eraser/undo/toggleTool/pan) and captures tilt into PenPoint.tilt -> EditorPoint.tilt.

W2 — Zoom flicker: page raster isolated in its own RepaintBoundary (safe interim);
definitive crisp-on-zoom fix gated on the on-device root-cause probe (plan M3).

Plans: ralplan-consensus plan at docs/plans/2026-06-22-badnote-pen-polish.md
(Architect APPROVE-WITH-MUST-FIX M1-M4 + Critic ITERATE->APPROVE).

Tests: 58/58 pass incl. shared-thinning invariant + thinning-affects-outline +
tilt-adapter round-trip. flutter analyze clean; linux debug build OK.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

lib/editor/canvas/ink_painters.dart

@@ -7,13 +7,21 @@
 import 'package:flutter/material.dart';
 import 'package:perfect_freehand/perfect_freehand.dart' as pf;
 
+import '../engine/stroke_geometry.dart' show kDefaultPenThinning;
 import 'pen_stroke.dart';
 
 /// Builds a filled outline [Path] for one stroke (already scaled to pixels).
 ///
 /// [pageSize] maps normalized coords to pixels. [isComplete] should be false
-/// for the in-progress live stroke so freehand tapers correctly.
-Path buildStrokePath(PenStroke stroke, Size pageSize, {required bool isComplete}) {
+/// for the in-progress live stroke so freehand tapers correctly. [thinning] is
+/// the pressure→width response (shared default [kDefaultPenThinning]); the
+/// SAME value drives the export path so screen and PDF never diverge.
+Path buildStrokePath(
+  PenStroke stroke,
+  Size pageSize, {
+  required bool isComplete,
+  double thinning = kDefaultPenThinning,
+}) {
   final pixelWidth = stroke.width * pageSize.width;
 
   final hasRealPressure = stroke.points.any((p) => p.pressure != null);
@@ -21,7 +29,7 @@ Path buildStrokePath(PenStroke stroke, Size pageSize, {required bool isComplete}
 
   final pfPoints = stroke.points
       .map(
-        (p) => pf.Point(
+        (p) => pf.PointVector(
           p.x * pageSize.width,
           p.y * pageSize.height,
           p.pressure ?? 0.5,
@@ -31,23 +39,27 @@ Path buildStrokePath(PenStroke stroke, Size pageSize, {required bool isComplete}
 
   final outline = pf.getStroke(
     pfPoints,
-    size: pixelWidth,
-    // Highlighter keeps a constant width (no thinning); pen thins like the
-    // existing ink_canvas (_drawFreehand uses 0.7).
-    thinning: isHighlighter ? 0.0 : 0.7,
-    smoothing: 0.5,
-    streamline: 0.5,
-    // Real stylus pressure → don't simulate; no pressure → let freehand fake
-    // it based on velocity (matches ink_canvas behavior).
-    simulatePressure: !hasRealPressure && !isHighlighter,
-    isComplete: isComplete,
+    options: pf.StrokeOptions(
+      size: pixelWidth,
+      // Highlighter keeps a constant width (no thinning); pen uses the
+      // configurable [thinning] so real Surface-Pen pressure changes width.
+      thinning: isHighlighter ? 0.0 : thinning,
+      smoothing: 0.5,
+      streamline: 0.5,
+      // Real stylus pressure → don't simulate; no pressure → let freehand fake
+      // it based on velocity. (perfect_freehand 2.x honors REAL pressure when
+      // simulatePressure is false — 1.0.4 ignored it, which made width
+      // unresponsive to pen force.)
+      simulatePressure: !hasRealPressure && !isHighlighter,
+      isComplete: isComplete,
+    ),
   );
 
   final path = Path();
   if (outline.isEmpty) return path;
-  path.moveTo(outline.first.x, outline.first.y);
+  path.moveTo(outline.first.dx, outline.first.dy);
   for (var i = 1; i < outline.length; i++) {
-    path.lineTo(outline[i].x, outline[i].y);
+    path.lineTo(outline[i].dx, outline[i].dy);
   }
   path.close();
   return path;
@@ -56,15 +68,23 @@ Path buildStrokePath(PenStroke stroke, Size pageSize, {required bool isComplete}
 /// Paints all committed strokes for the page. Repaints only when the stroke
 /// list identity or page size changes (kept behind a RepaintBoundary).
 class StaticInkPainter extends CustomPainter {
-  StaticInkPainter({required this.strokes, required this.pageSize});
+  StaticInkPainter({
+    required this.strokes,
+    required this.pageSize,
+    this.thinning = kDefaultPenThinning,
+  });
 
   final List<PenStroke> strokes;
   final Size pageSize;
 
+  /// Pressure→width response shared with the live/export paths.
+  final double thinning;
+
   @override
   void paint(Canvas canvas, Size size) {
     for (final stroke in strokes) {
-      final path = buildStrokePath(stroke, pageSize, isComplete: true);
+      final path =
+          buildStrokePath(stroke, pageSize, isComplete: true, thinning: thinning);
       if (path.getBounds().isEmpty) continue;
       canvas.drawPath(
         path,
@@ -80,23 +100,32 @@ class StaticInkPainter extends CustomPainter {
   bool shouldRepaint(StaticInkPainter old) =>
       !identical(old.strokes, strokes) ||
       old.strokes.length != strokes.length ||
-      old.pageSize != pageSize;
+      old.pageSize != pageSize ||
+      old.thinning != thinning;
 }
 
 /// Paints just the in-progress stroke (the live layer), kept behind its own
 /// RepaintBoundary so committed strokes don't repaint on every move.
 class LiveInkPainter extends CustomPainter {
-  LiveInkPainter({required this.stroke, required this.pageSize});
+  LiveInkPainter({
+    required this.stroke,
+    required this.pageSize,
+    this.thinning = kDefaultPenThinning,
+  });
 
   /// Current in-progress stroke, or null when nothing is being drawn.
   final PenStroke? stroke;
   final Size pageSize;
 
+  /// Pressure→width response shared with the static/export paths.
+  final double thinning;
+
   @override
   void paint(Canvas canvas, Size size) {
     final s = stroke;
     if (s == null || s.points.isEmpty) return;
-    final path = buildStrokePath(s, pageSize, isComplete: false);
+    final path =
+        buildStrokePath(s, pageSize, isComplete: false, thinning: thinning);
     if (path.getBounds().isEmpty) return;
     canvas.drawPath(
       path,
@@ -109,5 +138,7 @@ class LiveInkPainter extends CustomPainter {
 
   @override
   bool shouldRepaint(LiveInkPainter old) =>
-      !identical(old.stroke, stroke) || old.pageSize != pageSize;
+      !identical(old.stroke, stroke) ||
+      old.pageSize != pageSize ||
+      old.thinning != thinning;
 }