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/engine/stroke_geometry.dart

@@ -13,18 +13,30 @@ import 'package:perfect_freehand/perfect_freehand.dart' as pf;
 
 import 'stroke_model.dart';
 
+/// Canonical default for perfect_freehand's `thinning` (how strongly pressure
+/// modulates stroke width). The SINGLE source of truth shared by the on-screen
+/// painter ([buildStrokeOutline] here and `ink_painters.buildStrokePath`) and
+/// the PDF export path, so screen and export can never diverge. `0.85` =
+/// pressure visibly sweeps width; preserves the existing feel + export golden.
+/// Overridable per-stroke via [PenConfig.pressureSensitivity].
+const double kDefaultPenThinning = 0.85;
+
 /// Builds a closed, fillable outline [Path] for one [stroke], scaled into the
 /// pixel space of [pageSize] (which maps normalized [0,1] coords to pixels).
 ///
 /// [isComplete] should be false for the in-progress live stroke so freehand
 /// tapers the trailing end correctly, and true for committed strokes.
 ///
+/// [thinning] is perfect_freehand's pressure→width response (see
+/// [kDefaultPenThinning]); highlighter always forces `0.0` (constant width).
+///
 /// Returns an empty [Path] when the stroke has no points (or freehand produces
 /// no outline).
 Path buildStrokeOutline(
   EditorStroke stroke,
   Size pageSize, {
   required bool isComplete,
+  double thinning = kDefaultPenThinning,
 }) {
   final path = Path();
   if (stroke.points.isEmpty) return path;
@@ -36,7 +48,7 @@ Path buildStrokeOutline(
 
   final pfPoints = stroke.points
       .map(
-        (p) => pf.Point(
+        (p) => pf.PointVector(
           p.x * pageSize.width,
           p.y * pageSize.height,
           p.pressure ?? 0.5,
@@ -46,22 +58,25 @@ Path buildStrokeOutline(
 
   final outline = pf.getStroke(
     pfPoints,
-    size: pixelWidth,
-    // Highlighter keeps a constant width (no thinning); pen thins (0.7),
-    // matching the live recipe.
-    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 (highlighter never simulates).
-    simulatePressure: !hasRealPressure && !isHighlighter,
-    isComplete: isComplete,
+    options: pf.StrokeOptions(
+      size: pixelWidth,
+      // Highlighter keeps a constant width (no thinning); pen uses the
+      // configurable [thinning] so 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 (highlighter never simulates). perfect_freehand
+      // 2.x honors real pressure when simulatePressure is false.
+      simulatePressure: !hasRealPressure && !isHighlighter,
+      isComplete: isComplete,
+    ),
   );
 
   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;

lib/editor/engine/stroke_model.dart

@@ -103,12 +103,14 @@ abstract class EditorStroke with _$EditorStroke {
 
   // ---- Adapters -----------------------------------------------------------
 
-  /// Adapts an in-memory live [PenStroke] (normalized, no tilt/timestamp/kind).
+  /// Adapts an in-memory live [PenStroke] (normalized; carries tilt when the
+  /// native pen plugin supplied it, else null; no timestamp/pointerDeviceKind).
   factory EditorStroke.fromPenStroke(PenStroke stroke, {String? id}) =>
       EditorStroke(
         id: id ?? _uuid.v4(),
         points: stroke.points
-            .map((p) => EditorPoint(x: p.x, y: p.y, pressure: p.pressure))
+            .map((p) =>
+                EditorPoint(x: p.x, y: p.y, pressure: p.pressure, tilt: p.tilt))
             .toList(),
         tool: switch (stroke.kind) {
           PenStrokeKind.pen => EditorTool.pen,