From e63b01154b341924ffd834db178a67e6e7e6709c Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Wed, 21 Oct 2026 18:44:18 +0100 Subject: [PATCH 1/2] feat(app): add native content-sized graph stage node One content-sized stage node as an ordinary native control. Material uses stock Card.outlined/Card.filled inside an InkWell; Cupertino uses CupertinoButton.tinted/filled. onSelected reports the definition key verbatim, one merged button semantics node carries the exact label and selected state, recorded status is shown only when the caller supplies it, and invisible U+200B break opportunities reproduce the web's anywhere wrapping. Painted-boundary and painted-surface tests cover the UI-review 2x outline and Cupertino container defects. --- .../graph/widgets/graph_stage_node.dart | 126 ++++++++++ app/notes/P2-node.md | 178 +++++++++++++ .../widgets/graph_stage_node_render_test.dart | 210 ++++++++++++++++ .../graph/widgets/graph_stage_node_test.dart | 235 ++++++++++++++++++ app/tool/graph_node_probe.dart | 83 +++++++ app/tool/graph_node_probe.mjs | 151 +++++++++++ 6 files changed, 983 insertions(+) create mode 100644 app/lib/features/graph/widgets/graph_stage_node.dart create mode 100644 app/notes/P2-node.md create mode 100644 app/test/features/graph/widgets/graph_stage_node_render_test.dart create mode 100644 app/test/features/graph/widgets/graph_stage_node_test.dart create mode 100644 app/tool/graph_node_probe.dart create mode 100644 app/tool/graph_node_probe.mjs diff --git a/app/lib/features/graph/widgets/graph_stage_node.dart b/app/lib/features/graph/widgets/graph_stage_node.dart new file mode 100644 index 00000000..d28d4a26 --- /dev/null +++ b/app/lib/features/graph/widgets/graph_stage_node.dart @@ -0,0 +1,126 @@ +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; + +import '../../../ui/adaptive/host.dart'; +import '../domain/graph_definition.dart'; + +/// One content-sized stage node as an ordinary native control. +/// +/// [node] is the definition identity. [recordedStatus] is executed evidence the +/// caller read from the run; it is shown verbatim and never derived here, so an +/// unvisited or terminal definition node cannot be presented as executed. +class GraphStageNode extends StatelessWidget { + const GraphStageNode({ + super.key, + required this.node, + this.recordedStatus, + this.selected = false, + required this.onSelected, + }); + + final GraphNode node; + + /// The run's recorded status word for this node, or null when none exists. + final String? recordedStatus; + + /// Whether this definition node is the current graph selection. + final bool selected; + + /// Reports [node.key] exactly as the definition recorded it. + final ValueChanged onSelected; + + /// Content inset shared by both hosts. It is spacing, not a size: the control + /// still takes its size from its label, and the inset keeps wrapped glyphs + /// clear of a rounded surface's corners. + static const EdgeInsets _contentPadding = EdgeInsets.all(16); + + String? get _status { + final status = recordedStatus; + return status != null && status.trim().isNotEmpty ? status : null; + } + + String get _label { + final status = _status; + return status == null ? node.label : '${node.label}\n$status'; + } + + @override + Widget build(BuildContext context) { + final content = ExcludeSemantics(child: _content()); + void onPressed() => onSelected(node.key); + return MergeSemantics( + child: Semantics( + button: true, + selected: selected, + label: _label, + child: usesCupertinoHost(context) + ? _cupertinoButton(onPressed, content) + : _materialCard(onPressed, content), + ), + ); + } + + /// A stock card, not a stock button: Material's button shape is a stadium, + /// which assumes one line and cuts into a wrapped label's first and last + /// line. A card keeps the rounded-rectangle surface the web node uses, and + /// [selected] only chooses between two stock emphasis levels. + Widget _materialCard(VoidCallback onPressed, Widget content) { + final body = InkWell( + onTap: onPressed, + child: ConstrainedBox( + constraints: const BoxConstraints(minHeight: kMinInteractiveDimension), + child: Padding( + padding: _contentPadding, + child: Align( + alignment: AlignmentDirectional.centerStart, + widthFactor: 1, + heightFactor: 1, + child: content, + ), + ), + ), + ); + return selected + ? Card.filled( + margin: EdgeInsets.zero, + clipBehavior: Clip.antiAlias, + child: body, + ) + : Card.outlined( + margin: EdgeInsets.zero, + clipBehavior: Clip.antiAlias, + child: body, + ); + } + + /// Tinted is Cupertino's stock low-emphasis surface, so an unselected node is + /// still a visible node body; filled raises the selected one. + Widget _cupertinoButton(VoidCallback onPressed, Widget content) => selected + ? CupertinoButton.filled(onPressed: onPressed, child: content) + : CupertinoButton.tinted(onPressed: onPressed, child: content); + + Widget _content() { + final status = _status; + return Column( + mainAxisSize: MainAxisSize.min, + crossAxisAlignment: CrossAxisAlignment.start, + children: [ + Text(_breakable(node.label), softWrap: true), + if (status != null) Text(_breakable(status), softWrap: true), + ], + ); + } + + /// The web node uses `overflow-wrap: anywhere`; Flutter text does not break a + /// long unbroken key, so the same invisible break opportunities are added. + /// The visible text and the semantics label stay unchanged. + String _breakable(String value) { + final buffer = StringBuffer(); + for (final rune in value.runes) { + buffer + ..writeCharCode(rune) + ..write('\u200B'); + } + return buffer.toString(); + } +} diff --git a/app/notes/P2-node.md b/app/notes/P2-node.md new file mode 100644 index 00000000..680d2284 --- /dev/null +++ b/app/notes/P2-node.md @@ -0,0 +1,178 @@ +# P2-node — native content-sized stage-node control + +## This visit: both UI-review must-fixes + +| Finding | Change | +| --- | --- | +| Material stadium outline cut into a wrapped 2x label | Material no longer uses a stock **button**. It is a stock **card** body: `Card.outlined` when unselected, `Card.filled` when selected, wrapped in an `InkWell` with a 16 px content inset and the framework's `kMinInteractiveDimension` tap target. A card's painted shape is a rounded rectangle, so a long wrapped label stays inside the visible boundary at 1x and 2x. | +| Cupertino unselected stages and terminals were bare tinted text | Unselected Cupertino nodes are `CupertinoButton.tinted`, so every node has a visible native surface; selected stays `CupertinoButton.filled`. | + +Both fixes use stock widgets and stock variants only: no shape override, no +font, size, padding on a button, palette value or CSS token was added. + +| File | Lines | Responsibility | +| --- | ---: | --- | +| `lib/features/graph/widgets/graph_stage_node.dart` | 126 | one content-sized node as a native Material card or Cupertino button | +| `test/features/graph/widgets/graph_stage_node_test.dart` | 235 | key identity, semantics, keyboard, focus retention, wrap and terminal honesty | +| `test/features/graph/widgets/graph_stage_node_render_test.dart` | 210 | painted-boundary and painted-surface checks on real render objects/pixels | +| `tool/graph_node_probe.dart` | 83 | isolated browser fixture, 1x and 2x narrow cases | +| `tool/graph_node_probe.mjs` | 151 | headless-Chrome runner: labels, click identity, `aria-current`, captures | +| `notes/P2-node.md` | this page | facts for review/landing | + +No existing app source, domain, layout, routing, shell, `main.dart`, pubspec, +server, web client or platform file was modified. + +## Public API + +```dart +GraphStageNode({ + required GraphNode node, + String? recordedStatus, + bool selected = false, + required ValueChanged onSelected, +}) +``` + +Unchanged from the reviewed candidate. `onSelected` reports `node.key` verbatim, +including `#success` / `#failure`; the display label is never used as identity. + +## Native mapping + +| State | Material | Cupertino | +| --- | --- | --- | +| unselected | `Card.outlined` + `InkWell` | `CupertinoButton.tinted` | +| selected | `Card.filled` + `InkWell` | `CupertinoButton.filled` | + +- The host is chosen with the existing `usesCupertinoHost` helper. +- Material content sits in a `Padding` of 16 logical px inside the card, so + wrapped glyphs stay clear of the rounded corners; the control is still + content-sized (no fixed width or height) and grows with its label. +- `MergeSemantics` + `Semantics(button: true, selected: …, label: …)` keep one + accessibility node per stage: button role, tap action, exact label/status and + selected state. The painted content stays `ExcludeSemantics`. +- Selection keeps the same widget type on both hosts (`Card` / `CupertinoButton`), + so keyboard focus survives activation; the previous Material + `OutlinedButton` → `FilledButton` swap replaced the focus node (review note 1). +- **Break-anywhere parity.** The web node uses `overflow-wrap: anywhere`; the + painted lines get invisible U+200B break opportunities. The accessible label + stays exact, with no invisible characters. +- **Recorded status only.** `recordedStatus` is shown verbatim on a second line + when non-blank; blank or whitespace-only status adds no line. Nothing is + derived from `terminal`, `stageIndex` or the label, so a terminal reads only + `Success` / `Failure` unless the caller supplies real run evidence. + +## Rendered checks (new) + +`graph_stage_node_render_test.dart` closes the gap the previous 2x test had +(line metrics versus paragraph width, not glyphs versus the painted boundary): + +- **Painted-boundary containment.** Reads the actual `Material.shape` and render + rect of the Material control, builds its outer `Path`, converts every laid-out + line box of the label to card-local coordinates with + `RenderParagraph.localToGlobal`, and requires all four corners of every line + box to be inside the painted path — at 1x and 2x in a 150 logical px box. + A rounded rectangle is convex, so corner containment means the whole line box + is inside; no padding/shape override can hide a crossing. +- **The check has teeth.** Running the same test against the identical widget + while a `StadiumBorder` is temporarily set on the card fails with + `at 1.0x a glyph box corner at Offset(16.1, 19.0) escapes the painted control + boundary`. The shape assertion (`material node paints a rounded surface, not a + stadium`) fails too. The override was reverted before this page was written. +- **Cupertino container.** Renders the unselected node over an opaque page, + reads pixels back from a real `RepaintBoundary.toImage`, and requires the point + just inside the control's left edge to differ from the page background by more + than 24/255. Reverting to plain `CupertinoButton` fails this test. +- **Visible selection.** The same pixel path requires the painted surface to + change between unselected and selected in both hosts. +- **Focus retention.** Tab + Enter on the Material node, then the primary focus + must still be a descendant of the node's `Card`. + +## Checks actually run + +``` +dart format --output=none --set-exit-if-changed lib/features/graph/widgets \ + test/features/graph/widgets tool/graph_node_probe.dart # 0 changed, exit 0 +flutter test test/features/graph/widgets # 13 passed +flutter test # 460 passed +flutter analyze # No issues found! +flutter build web -t tool/graph_node_probe.dart --release # ✓ Built build/web +PROBE_VARIANT=material PROBE_SCHEME=dark node tool/graph_node_probe.mjs # passed, 6 captures +PROBE_VARIANT=material PROBE_SCHEME=light node tool/graph_node_probe.mjs # passed, 6 captures +PROBE_VARIANT=cupertino PROBE_SCHEME=dark node tool/graph_node_probe.mjs # passed, 6 captures +PROBE_VARIANT=cupertino PROBE_SCHEME=light node tool/graph_node_probe.mjs # passed, 6 captures +``` + +The runner asserts the initial labels (`Selected: build`, `plan`, `build`, +`running`, `Success`, `Failure`), that exactly the `build` node carries +`aria-current="true"` (Flutter web maps `Semantics(selected:)` to `aria-current`, +not `aria-selected` — review note 5), that clicking `plan` and `Success` yields +exactly `Selected: plan` and `Selected: #success`, and that the selected +`aria-current` moves to `plan`. + +## Browser evidence (current) + +Real headless Chrome, loopback fixture only, 390×844 phone and 1280×800 desktop; +dark is Chrome's default scheme, light uses `prefers-color-scheme: light`. + +- `/Users/alan/.local/share/pipelines/data/artifacts/64/public/p2-node-fix-material-dark-phone.png` +- `.../p2-node-fix-material-light-phone.png` +- `.../p2-node-fix-material-dark-desktop.png` +- `.../p2-node-fix-material-long-2x-crop.png` (2x enlargement of the wrapped 2x node) +- `.../p2-node-fix-material-long-1x-crop.png` +- `.../p2-node-fix-material-selected-plan.png` +- `.../p2-node-fix-cupertino-dark-phone.png` +- `.../p2-node-fix-cupertino-light-phone.png` +- `.../p2-node-fix-cupertino-dark-desktop.png` +- `.../p2-node-fix-cupertino-long-2x-crop.png` +- `.../p2-node-fix-cupertino-selected-terminal.png` +- Runner: `.../public/graph_node_probe.mjs` (same file as `tool/graph_node_probe.mjs`) + +The visit-1 captures (`material-nodes-*.png`, `cupertino-nodes-*.png`) and the UI +review crops are superseded by this set; they are kept only as history. + +Pixel measurements of the current 2x crops (crops are 2x, 8 logical px margin): + +| Node | Container (px) | Glyph ink (px) | Corner band | +| --- | --- | --- | --- | +| Material | x 16–316, y 16–560 | x 50–269, y 66–507 | 24 px (radius 12) | +| Cupertino | x 16–316, y 16–640 | x 60–268, y 63–590 | 16 px (radius 8) | + +At 1x the same nodes measure Material ink x 50–268, y 61–147 inside a +x 16–316, y 16–200 container, and Cupertino ink x 59–264, y 59–164. +No glyph ink enters a corner band or crosses the visible boundary in either +scaling; the previous outline crossing is gone. + +Inspected captures: Material shows outlined node bodies, a visibly filled +selected node, `running` only on `build`, and no status on either terminal; +Cupertino shows a tinted body for every unselected node and a filled selected +node in both light and dark. + +## Honest limits + +- **Material selection is tonal.** `Card.filled` (surfaceContainerHighest) versus + `Card.outlined` (surface + border) is the strongest stock card pairing, but it + is lighter than the previous primary-filled button. It is visible in the + captures and asserted by pixels; if UI review wants a stronger accent, that + needs an explicit theme-colour decision rather than a bespoke palette. +- **Stage vs terminal is label-driven.** Both hosts give every node the same + stock container; the web's terminal pill and outcome tints are styling the + rules exclude. Terminals read `Success` / `Failure` (and no invented status). + Composition can add a stock type affordance if it is still wanted. +- **Material content inset is a spacing choice.** 16 logical px inside the card + keeps wrapped glyphs clear of the 12 px corner radius; the framework's + `kMinInteractiveDimension` keeps the tap target at the native minimum. +- **No measurement API yet.** The control shrink-wraps; the caller imposes width + (the fixture uses 150). The renderer still needs to measure this same control. +- **`onSelected` identity and wrapping are unchanged**, but U+200B break + opportunities would split exotic grapheme clusters (acceptable for stage keys). +- **Space activation** is a framework default and is not exercised; only + Tab + Enter is tested. +- **No composition.** No canvas, layout invocation, edge painter, visit menu, + shell registration or `main.dart` wiring: the widget is still not visible in + the app. +- **Not committed.** This stage forbids commit/push/deploy; the paths stay + untracked on `flutter/p2-node-widget` for Review and Land. +- **Fixture-only browser evidence**: no Pipelines server, real run, + authentication change, deployment or production data. +- **Mobile unverified**: web test/analyze/build only; no Android/iOS build, + emulator, ADB or install. diff --git a/app/test/features/graph/widgets/graph_stage_node_render_test.dart b/app/test/features/graph/widgets/graph_stage_node_render_test.dart new file mode 100644 index 00000000..113a09ae --- /dev/null +++ b/app/test/features/graph/widgets/graph_stage_node_render_test.dart @@ -0,0 +1,210 @@ +import 'dart:typed_data'; +import 'dart:ui' as ui; + +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; +import 'package:flutter/rendering.dart'; +import 'package:flutter_test/flutter_test.dart'; + +import 'package:pipelines_app/features/graph/domain/graph_definition.dart'; +import 'package:pipelines_app/features/graph/widgets/graph_stage_node.dart'; + +const _stage = GraphNode(key: 'build', terminal: false, stageIndex: 1); +const _long = GraphNode( + key: 'implementer-with-an-unshortened-stage-label', + terminal: false, + stageIndex: 2, +); +const _longLabel = 'implementer-with-an-unshortened-stage-label'; + +Widget _material(Widget child) => MaterialApp( + home: Scaffold(body: Center(child: child)), +); + +Widget _cupertino(Widget child) => CupertinoApp( + home: CupertinoPageScaffold(child: Center(child: child)), +); + +/// The node centred on an opaque page, inside its own repaint boundary so the +/// painted result can be read back as pixels. +Widget _framed(Key key, Widget Function(Widget) wrap, Widget child) => wrap( + RepaintBoundary( + key: key, + child: ColoredBox( + color: const Color(0xFFFFFFFF), + child: Center(child: child), + ), + ), +); + +Finder get _materialSurface => + find.descendant(of: find.byType(Card), matching: find.byType(Material)); + +Finder _visual(String label) => find.byWidgetPredicate( + (widget) => widget is Text && widget.data?.replaceAll('\u200B', '') == label, +); + +final class _Shot { + _Shot(this.bytes, this.size, this.origin); + + final Uint8List bytes; + final Size size; + final Offset origin; + + Color at(Offset global) { + final x = (global.dx - origin.dx).round(); + final y = (global.dy - origin.dy).round(); + expect(x, inInclusiveRange(0, size.width.round() - 1)); + expect(y, inInclusiveRange(0, size.height.round() - 1)); + final i = (y * size.width.round() + x) * 4; + return Color.fromARGB(bytes[i + 3], bytes[i], bytes[i + 1], bytes[i + 2]); + } +} + +Future<_Shot> _shot(WidgetTester tester, Key key) async { + final boundary = tester.renderObject(find.byKey(key)); + final image = (await tester.runAsync(() => boundary.toImage()))!; + final data = (await tester.runAsync( + () => image.toByteData(format: ui.ImageByteFormat.rawRgba), + ))!; + image.dispose(); + return _Shot( + data.buffer.asUint8List(), + tester.getSize(find.byKey(key)), + tester.getTopLeft(find.byKey(key)), + ); +} + +double _distance(Color a, Color b) => [ + (a.r - b.r).abs() * 255, + (a.g - b.g).abs() * 255, + (a.b - b.b).abs() * 255, +].reduce((value, next) => value > next ? value : next); + +void main() { + testWidgets('material node paints a rounded surface, not a stadium', ( + tester, + ) async { + await tester.pumpWidget( + _material(GraphStageNode(node: _stage, onSelected: (_) {})), + ); + final material = tester.widget(_materialSurface); + expect( + material.shape, + isA(), + reason: + 'Material button shapes are stadiums; a stadium border cuts into a ' + 'wrapped label the way the reviewed 2x control did', + ); + }); + + testWidgets('wrapped glyph boxes stay inside the painted material surface', ( + tester, + ) async { + for (final scale in [1.0, 2.0]) { + await tester.pumpWidget( + _material( + Builder( + builder: (context) => MediaQuery( + data: MediaQuery.of( + context, + ).copyWith(textScaler: TextScaler.linear(scale)), + child: SizedBox( + width: 150, + child: GraphStageNode(node: _long, onSelected: (_) {}), + ), + ), + ), + ), + ); + expect(tester.takeException(), isNull); + + final rect = tester.getRect(_materialSurface); + final shape = tester.widget(_materialSurface).shape!; + final path = shape.getOuterPath(Offset.zero & rect.size); + final paragraph = tester.renderObject( + _visual(_longLabel), + ); + final boxes = paragraph.getBoxesForSelection( + TextSelection( + baseOffset: 0, + extentOffset: paragraph.text.toPlainText().length, + ), + ); + expect(boxes, isNotEmpty); + for (final box in boxes) { + final corners = [ + Offset(box.left, box.top), + Offset(box.right, box.top), + Offset(box.left, box.bottom), + Offset(box.right, box.bottom), + ]; + for (final corner in corners) { + final local = paragraph.localToGlobal(corner) - rect.topLeft; + expect( + path.contains(local), + isTrue, + reason: + 'at ${scale}x a glyph box corner at $local escapes the ' + 'painted control boundary $rect', + ); + } + } + } + }); + + testWidgets('unselected cupertino node paints a visible container', ( + tester, + ) async { + final key = GlobalKey(); + await tester.pumpWidget( + _framed( + key, + _cupertino, + GraphStageNode(node: _stage, onSelected: (_) {}), + ), + ); + final shot = await _shot(tester, key); + final rect = tester.getRect(find.byType(CupertinoButton)); + // Just inside the left edge of the control, clear of the label's inset. + final body = shot.at(rect.centerLeft + const Offset(4, 0)); + final page = shot.at(const Offset(4, 4)); + expect( + _distance(body, page), + greaterThan(24), + reason: 'an unselected cupertino node needs its own visible surface', + ); + }); + + testWidgets('selected state changes the painted surface in both hosts', ( + tester, + ) async { + for (final wrap in [_material, _cupertino]) { + final colors = {}; + for (final selected in [false, true]) { + final key = GlobalKey(); + await tester.pumpWidget( + _framed( + key, + wrap, + GraphStageNode( + node: _stage, + selected: selected, + onSelected: (_) {}, + ), + ), + ); + final shot = await _shot(tester, key); + final rect = tester.getRect(find.byType(GraphStageNode)); + colors[selected] = shot.at(rect.centerLeft + const Offset(4, 0)); + } + expect( + _distance(colors[false]!, colors[true]!), + greaterThan(16), + reason: + 'selection must be visible, not only announced: the surface fill ' + 'and the outlined border change together', + ); + } + }); +} diff --git a/app/test/features/graph/widgets/graph_stage_node_test.dart b/app/test/features/graph/widgets/graph_stage_node_test.dart new file mode 100644 index 00000000..3d2ade29 --- /dev/null +++ b/app/test/features/graph/widgets/graph_stage_node_test.dart @@ -0,0 +1,235 @@ +import 'dart:ui' show Tristate; + +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; +import 'package:flutter/rendering.dart'; +import 'package:flutter/services.dart'; +import 'package:flutter_test/flutter_test.dart'; + +import 'package:pipelines_app/features/graph/domain/graph_definition.dart'; +import 'package:pipelines_app/features/graph/widgets/graph_stage_node.dart'; + +const _stage = GraphNode(key: 'build', terminal: false, stageIndex: 1); +const _success = GraphNode(key: '#success', terminal: true); +const _failure = GraphNode(key: '#failure', terminal: true); + +Widget _material(Widget child) => MaterialApp( + home: Scaffold(body: Center(child: child)), +); + +Widget _cupertino(Widget child) => CupertinoApp( + home: CupertinoPageScaffold(child: Center(child: child)), +); + +/// Applies a 2x text scale below the app so the fixture renders as a real +/// scale-2 layout rather than a test-only text property. +Widget _scaled(Widget child) => Builder( + builder: (context) => MediaQuery( + data: MediaQuery.of( + context, + ).copyWith(textScaler: const TextScaler.linear(2)), + child: child, + ), +); + +/// The merged accessibility node a screen reader receives for one node. +SemanticsData _semantics(WidgetTester tester) => + tester.getSemantics(find.byType(MergeSemantics)).getSemanticsData(); + +void _expectSelectable(WidgetTester tester, {required bool selected}) { + final data = _semantics(tester); + expect(data.flagsCollection.isButton, isTrue); + expect(data.flagsCollection.isSelected == Tristate.isTrue, selected); + expect(data.actions & SemanticsAction.tap.index, isNot(0)); +} + +/// Finds the visual line for [label], ignoring its invisible break chars. +Finder _visual(String label) => find.byWidgetPredicate( + (widget) => widget is Text && widget.data?.replaceAll('\u200B', '') == label, +); + +void main() { + testWidgets('selection callback carries the exact definition key', ( + tester, + ) async { + final picked = []; + await tester.pumpWidget( + _material(GraphStageNode(node: _success, onSelected: picked.add)), + ); + + await tester.tap(find.byType(GraphStageNode)); + await tester.pump(); + + expect(picked, ['#success']); + _expectSelectable(tester, selected: false); + expect(_semantics(tester).label, 'Success'); + }); + + testWidgets('selected node is announced selected in both native hosts', ( + tester, + ) async { + await tester.pumpWidget( + _material( + GraphStageNode(node: _stage, selected: true, onSelected: (_) {}), + ), + ); + expect(find.byType(Card), findsOneWidget); + expect(find.byType(InkWell), findsOneWidget); + _expectSelectable(tester, selected: true); + + await tester.pumpWidget( + _cupertino( + GraphStageNode(node: _stage, selected: true, onSelected: (_) {}), + ), + ); + expect(find.byType(CupertinoButton), findsOneWidget); + expect(find.byType(Card), findsNothing); + _expectSelectable(tester, selected: true); + }); + + testWidgets('unselected node is not announced selected', (tester) async { + await tester.pumpWidget( + _material(GraphStageNode(node: _stage, onSelected: (_) {})), + ); + expect(find.byType(Card), findsOneWidget); + _expectSelectable(tester, selected: false); + }); + + testWidgets('keyboard activation selects the node', (tester) async { + for (final wrap in [_material, _cupertino]) { + final picked = []; + await tester.pumpWidget( + wrap(GraphStageNode(node: _stage, onSelected: picked.add)), + ); + await tester.sendKeyEvent(LogicalKeyboardKey.tab); + await tester.pumpAndSettle(); + await tester.sendKeyEvent(LogicalKeyboardKey.enter); + await tester.pumpAndSettle(); + expect(picked, ['build']); + } + }); + + testWidgets('keyboard selection keeps focus inside the material node', ( + tester, + ) async { + var selected = false; + await tester.pumpWidget( + _material( + StatefulBuilder( + builder: (context, setState) => GraphStageNode( + node: _stage, + selected: selected, + onSelected: (_) => setState(() => selected = true), + ), + ), + ), + ); + await tester.sendKeyEvent(LogicalKeyboardKey.tab); + await tester.pumpAndSettle(); + await tester.sendKeyEvent(LogicalKeyboardKey.enter); + await tester.pumpAndSettle(); + expect(selected, isTrue); + + final focused = FocusManager.instance.primaryFocus; + expect(focused?.context, isNotNull); + expect( + focused?.context?.findAncestorWidgetOfExactType(), + isNotNull, + reason: 'switching card emphasis must not drop keyboard focus', + ); + }); + + testWidgets('long label wraps unshortened in a narrow 2x layout', ( + tester, + ) async { + const label = 'implementer-with-an-unshortened-stage-label'; + const node = GraphNode(key: label, terminal: false, stageIndex: 0); + for (final wrap in [_material, _cupertino]) { + await tester.pumpWidget( + wrap( + _scaled( + SizedBox( + width: 150, + child: GraphStageNode(node: node, onSelected: (_) {}), + ), + ), + ), + ); + + expect(tester.takeException(), isNull); + final text = tester.widget(_visual(label)); + expect(text.data!.replaceAll('\u200B', ''), label); + expect(text.maxLines, isNull); + expect(text.overflow, isNull); + final paragraph = tester.renderObject(_visual(label)); + expect(paragraph.size.width, lessThanOrEqualTo(150)); + expect( + paragraph.size.height, + greaterThan(50), + reason: 'the 2x label must occupy more than one 2x text line', + ); + // No glyph may paint outside the paragraph: every laid-out line, + // including a hyphen-broken segment, fits the width the control gave it. + final painter = TextPainter( + text: paragraph.text, + textDirection: paragraph.textDirection, + textScaler: paragraph.textScaler, + textAlign: paragraph.textAlign, + )..layout(maxWidth: paragraph.size.width); + expect( + painter.computeLineMetrics().every( + (line) => line.width <= paragraph.size.width + 0.5, + ), + isTrue, + reason: 'an unshortened label must wrap, not paint over the control', + ); + } + }); + + testWidgets('terminal shows its definition label and no invented status', ( + tester, + ) async { + for (final node in [_success, _failure]) { + await tester.pumpWidget( + _material(GraphStageNode(node: node, onSelected: (_) {})), + ); + final texts = tester + .widgetList(find.byType(Text)) + .map((text) => text.data?.replaceAll('\u200B', '')) + .toList(); + expect(texts, [node.label]); + expect(texts.join(' ').toLowerCase(), isNot(contains('executed'))); + expect(texts.join(' ').toLowerCase(), isNot(contains('visited'))); + expect(_semantics(tester).label, node.label); + expect(_semantics(tester).label, isNot(contains('\u200B'))); + } + }); + + testWidgets('a recorded status is shown verbatim', (tester) async { + await tester.pumpWidget( + _cupertino( + GraphStageNode( + node: _stage, + recordedStatus: 'failed', + onSelected: (_) {}, + ), + ), + ); + expect(_visual('build'), findsOneWidget); + expect(_visual('failed'), findsOneWidget); + final label = _semantics(tester).label; + expect(label, contains('build')); + expect(label, contains('failed')); + expect(label, isNot(contains('\u200B'))); + }); + + testWidgets('a blank recorded status adds no line', (tester) async { + await tester.pumpWidget( + _material( + GraphStageNode(node: _stage, recordedStatus: ' ', onSelected: (_) {}), + ), + ); + expect(find.byType(Text), findsOneWidget); + expect(_semantics(tester).label, 'build'); + }); +} diff --git a/app/tool/graph_node_probe.dart b/app/tool/graph_node_probe.dart new file mode 100644 index 00000000..ff94f501 --- /dev/null +++ b/app/tool/graph_node_probe.dart @@ -0,0 +1,83 @@ +import 'package:flutter/cupertino.dart'; +import 'package:flutter/material.dart'; + +import 'package:pipelines_app/features/graph/domain/graph_definition.dart'; +import 'package:pipelines_app/features/graph/widgets/graph_stage_node.dart'; + +const _longKey = 'implementer-with-an-unshortened-stage-label'; +const _oneXKey = 'narrow-one-x-stage-key-that-wraps'; + +/// Keys rendered in a 150 logical px box, with the text scale applied to them. +const _scaled = {_longKey: 2.0, _oneXKey: 1.0}; + +const _nodes = [ + GraphNode(key: 'plan', terminal: false, stageIndex: 0), + GraphNode(key: 'build', terminal: false, stageIndex: 1), + GraphNode(key: _longKey, terminal: false, stageIndex: 2), + GraphNode(key: _oneXKey, terminal: false, stageIndex: 3), + GraphNode(key: '#success', terminal: true), + GraphNode(key: '#failure', terminal: true), +]; + +/// A fixture-only page: one measured node per definition identity, with the +/// selected key reported so a browser click can prove the exact callback. +class _Probe extends StatefulWidget { + const _Probe({required this.cupertino}); + + final bool cupertino; + + @override + State<_Probe> createState() => _ProbeState(); +} + +class _ProbeState extends State<_Probe> { + String? _selected = 'build'; + + Widget _node(GraphNode node) { + final child = GraphStageNode( + node: node, + recordedStatus: node.key == 'build' ? 'running' : null, + selected: node.key == _selected, + onSelected: (key) => setState(() => _selected = key), + ); + final scale = _scaled[node.key]; + if (scale == null) return child; + return MediaQuery( + data: MediaQuery.of( + context, + ).copyWith(textScaler: TextScaler.linear(scale)), + child: SizedBox(width: 150, child: child), + ); + } + + @override + Widget build(BuildContext context) { + final page = ListView( + padding: const EdgeInsets.all(16), + children: [ + Text('Selected: ${_selected ?? 'none'}'), + const SizedBox(height: 12), + Wrap( + spacing: 12, + runSpacing: 12, + children: [for (final node in _nodes) _node(node)], + ), + ], + ); + return widget.cupertino + ? CupertinoPageScaffold(child: SafeArea(child: page)) + : Scaffold(body: SafeArea(child: page)); + } +} + +void main() { + final cupertino = Uri.base.queryParameters['style'] == 'cupertino'; + runApp( + cupertino + ? CupertinoApp(home: const _Probe(cupertino: true)) + : MaterialApp( + theme: ThemeData(platform: TargetPlatform.android), + home: const _Probe(cupertino: false), + ), + ); +} diff --git a/app/tool/graph_node_probe.mjs b/app/tool/graph_node_probe.mjs new file mode 100644 index 00000000..f5145df8 --- /dev/null +++ b/app/tool/graph_node_probe.mjs @@ -0,0 +1,151 @@ +// Browser acceptance for the isolated GraphStageNode fixture. +// +// Serves the probe build (`flutter build web -t tool/graph_node_probe.dart`) on +// an OS-assigned loopback port, drives a real headless Chrome, asserts labels, +// selection identity and the selected ARIA state, and writes captures. +// +// PROBE_VARIANT=material|cupertino PROBE_SCHEME=dark|light \ +// OPENCODE_ARTIFACT_DIR= node tool/graph_node_probe.mjs +import { createServer } from 'node:http'; +import { spawn } from 'node:child_process'; +import { once } from 'node:events'; +import { setTimeout as delay } from 'node:timers/promises'; +import { join, extname, resolve, sep } from 'node:path'; +import { tmpdir } from 'node:os'; +import { mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'; + +const root = resolve(process.env.PROBE_WEB_ROOT ?? join(process.cwd(), 'build/web')); +const variant = process.env.PROBE_VARIANT ?? 'material'; +const scheme = process.env.PROBE_SCHEME ?? 'dark'; +const artifactDir = process.env.OPENCODE_ARTIFACT_DIR ?? join(tmpdir(), 'graph-node-capture'); +const prefix = scheme === 'light' ? 'light-' : ''; +const longKey = 'implementer-with-an-unshortened-stage-label'; +const oneXKey = 'narrow-one-x-stage-key-that-wraps'; +await mkdir(artifactDir, { recursive: true }); +const mime = { '.html': 'text/html', '.js': 'text/javascript', '.json': 'application/json', '.wasm': 'application/wasm', '.png': 'image/png', '.ico': 'image/x-icon' }; +const server = createServer(async (req, res) => { + try { + const path = resolve(root, '.' + decodeURIComponent(new URL(req.url, 'http://localhost').pathname)); + if (path !== root && !path.startsWith(root + sep)) return res.writeHead(403).end(); + const filePath = path === root || path.endsWith('/') ? join(path, 'index.html') : path; + const file = await readFile(filePath); + res.writeHead(200, { 'content-type': mime[extname(filePath)] ?? 'application/octet-stream' }).end(file); + } catch { res.writeHead(404).end('not found'); } +}); +server.listen(0, '127.0.0.1'); +await once(server, 'listening'); +const port = server.address().port; +const profile = await mkdtemp(join(tmpdir(), 'graph-node-chrome-')); +const chrome = spawn('/Applications/Google Chrome.app/Contents/MacOS/Google Chrome', [ + '--headless=new', '--no-first-run', '--no-default-browser-check', '--disable-gpu', + '--remote-debugging-port=0', `--user-data-dir=${profile}`, 'about:blank', +], { stdio: ['ignore', 'ignore', 'pipe'] }); +let stderr = ''; +chrome.stderr.on('data', data => { stderr += data; }); +const waitFor = async fn => { + for (let i = 0; i < 100; i++) { const value = await fn(); if (value) return value; await delay(100); } + throw new Error('Timed out waiting for Chrome DevTools'); +}; +let ws; +try { + const endpoint = await waitFor(() => stderr.match(/DevTools listening on (ws:\/\/[^\s]+)/)?.[1]); + ws = new WebSocket(endpoint); + await once(ws, 'open'); + let id = 0; + const pending = new Map(); + ws.addEventListener('message', event => { + const msg = JSON.parse(event.data); + if (msg.id && pending.has(msg.id)) { pending.get(msg.id)(msg); pending.delete(msg.id); } + }); + const send = (method, params = {}, sessionId) => new Promise(resolve => { + const callId = ++id; pending.set(callId, resolve); + ws.send(JSON.stringify({ id: callId, method, params, ...(sessionId ? { sessionId } : {}) })); + }); + const created = await send('Target.createTarget', { url: 'about:blank' }); + const target = created.result.targetId; + const session = (await send('Target.attachToTarget', { targetId: target, flatten: true })).result.sessionId; + await send('Page.enable', {}, session); + await send('Runtime.enable', {}, session); + await send('Emulation.setEmulatedMedia', { + features: [{ name: 'prefers-color-scheme', value: scheme }], + }, session); + const navigation = await send('Page.navigate', { url: `http://127.0.0.1:${port}/?style=${variant}` }, session); + if (navigation.error || navigation.result?.errorText) throw new Error(JSON.stringify(navigation)); + const evaluate = async expression => { + const response = await send('Runtime.evaluate', { expression, returnByValue: true, awaitPromise: true }, session); + if (response.error) throw new Error(`Runtime.evaluate failed: ${JSON.stringify(response)}`); + return response.result?.result?.value; + }; + await delay(3500); + const loaded = await evaluate('({url:location.href, ready:document.readyState})'); + if (!loaded?.url.includes(`127.0.0.1:${port}/?style=${variant}`)) throw new Error(`Fixture did not load: ${JSON.stringify(loaded)}`); + await evaluate("document.querySelector('flt-semantics-placeholder')?.click()"); + await delay(2500); + const semantics = () => evaluate("[...document.querySelectorAll('flt-semantics')].map(x=>({label:(x.getAttribute('aria-label')||x.innerText||'').trim(), selected:x.getAttribute('aria-current'), role:x.getAttribute('role')}))"); + const nodeAt = label => `[...document.querySelectorAll('flt-semantics')].find(x => (x.getAttribute('aria-label')||x.innerText||'').trim() === ${JSON.stringify(label)})`; + const initial = await semantics(); + const labels = initial.map(x => x.label); + for (const needle of ['Selected: build', 'plan', 'build', 'running', 'Success', 'Failure']) { + if (!labels.some(x => x.includes(needle))) throw new Error(`Missing semantics ${needle}: ${JSON.stringify(labels)}`); + } + // Flutter web maps Semantics(selected:) to aria-current, not aria-selected. + const current = initial.find(x => x.selected === 'true'); + // The fixture's selected node carries its recorded status, so its accessible + // label is 'build\nrunning'. + if (!current?.label.startsWith('build')) throw new Error(`Selected node is not announced: ${JSON.stringify(initial)}`); + if (process.env.PROBE_DEBUG) console.log(JSON.stringify(initial, null, 2)); + const clickLabel = async label => { + const point = await evaluate(`(() => { const e=${nodeAt(label)}; if (!e) return null; const r=e.getBoundingClientRect(); return {x:r.x+r.width/2,y:r.y+r.height/2}; })()`); + if (!point) return false; + await send('Input.dispatchMouseEvent', { type: 'mousePressed', x: point.x, y: point.y, button: 'left', clickCount: 1 }, session); + await send('Input.dispatchMouseEvent', { type: 'mouseReleased', x: point.x, y: point.y, button: 'left', clickCount: 1 }, session); + return true; + }; + const nodeRect = async label => evaluate(`(() => { const e=${nodeAt(label)}; if (!e) return null; const r=e.getBoundingClientRect(); return {x:r.x,y:r.y,width:r.width,height:r.height}; })()`); + const capture = async (name, width, height, scale = 1) => { + await send('Emulation.setDeviceMetricsOverride', { width, height, deviceScaleFactor: 1, mobile: width < 600 }, session); + await delay(2500); + const data = (await send('Page.captureScreenshot', { format: 'png', captureBeyondViewport: false }, session)).result.data; + await writeFile(`${artifactDir}/${prefix}${variant}-${name}.png`, Buffer.from(data, 'base64')); + }; + await capture('nodes-phone', 390, 844); + await capture('nodes-desktop', 1280, 800); + // Enlarged crops of the wrapped cases: the reviewed Material defect was + // glyph ink crossing the painted boundary at 2x. + const crops = {}; + for (const [name, key] of [['long-2x', longKey], ['long-1x', oneXKey]]) { + const rect = await nodeRect(key); + if (!rect) throw new Error(`Missing node ${key}`); + crops[name] = rect; + const data = (await send('Page.captureScreenshot', { + format: 'png', + clip: { x: rect.x - 8, y: rect.y - 8, width: rect.width + 16, height: rect.height + 16, scale: 2 }, + captureBeyondViewport: false, + }, session)).result.data; + await writeFile(`${artifactDir}/${prefix}${variant}-${name}-crop.png`, Buffer.from(data, 'base64')); + } + if (!await clickLabel('plan')) throw new Error('Could not click plan node'); + await delay(600); + const afterPlan = await evaluate('document.body.innerText'); + if (!afterPlan.includes('Selected: plan')) throw new Error(`plan callback did not carry its key: ${afterPlan}`); + const planCurrent = (await semantics()).find(x => x.selected === 'true'); + if (planCurrent?.label !== 'plan') throw new Error(`plan is not announced selected: ${JSON.stringify(planCurrent)}`); + await capture('nodes-selected-plan', 390, 844); + if (!await clickLabel('Success')) throw new Error('Could not click Success terminal'); + await delay(600); + const afterTerminal = await evaluate('document.body.innerText'); + if (!afterTerminal.includes('Selected: #success')) throw new Error(`terminal callback did not carry its key: ${afterTerminal}`); + await capture('nodes-selected-terminal', 390, 844); + console.log(JSON.stringify({ + variant, scheme, labels, crops, + captures: [`${prefix}${variant}-nodes-phone.png`, `${prefix}${variant}-nodes-desktop.png`, + `${prefix}${variant}-nodes-selected-plan.png`, `${prefix}${variant}-nodes-selected-terminal.png`, + `${prefix}${variant}-long-2x-crop.png`, `${prefix}${variant}-long-1x-crop.png`], + }, null, 2)); +} finally { + ws?.close(); + chrome.kill('SIGTERM'); + await Promise.race([once(chrome, 'exit'), delay(3000)]); + server.close(); + await rm(profile, { recursive: true, force: true }); +} From 7eaab4b3590d527f38ff8589e4f66be02ebe85d3 Mon Sep 17 00:00:00 2001 From: Alan Silva Date: Wed, 21 Oct 2026 18:47:56 +0100 Subject: [PATCH 2/2] docs(app): record real dark-theme evidence for the stage-node probe The fixture had no darkTheme, so its Material "dark" captures were the default light theme. Supply the stock dark theme and themeMode.system, rerun the probe in both schemes, and correct the note's test counts, capture names and branch state. --- app/notes/P2-node.md | 60 ++++++++++++++++++++-------------- app/tool/graph_node_probe.dart | 7 ++++ 2 files changed, 42 insertions(+), 25 deletions(-) diff --git a/app/notes/P2-node.md b/app/notes/P2-node.md index 680d2284..98d4ae72 100644 --- a/app/notes/P2-node.md +++ b/app/notes/P2-node.md @@ -15,7 +15,7 @@ font, size, padding on a button, palette value or CSS token was added. | `lib/features/graph/widgets/graph_stage_node.dart` | 126 | one content-sized node as a native Material card or Cupertino button | | `test/features/graph/widgets/graph_stage_node_test.dart` | 235 | key identity, semantics, keyboard, focus retention, wrap and terminal honesty | | `test/features/graph/widgets/graph_stage_node_render_test.dart` | 210 | painted-boundary and painted-surface checks on real render objects/pixels | -| `tool/graph_node_probe.dart` | 83 | isolated browser fixture, 1x and 2x narrow cases | +| `tool/graph_node_probe.dart` | 90 | isolated browser fixture with stock light/dark themes, 1x and 2x narrow cases | | `tool/graph_node_probe.mjs` | 151 | headless-Chrome runner: labels, click identity, `aria-current`, captures | | `notes/P2-node.md` | this page | facts for review/landing | @@ -87,21 +87,27 @@ including `#success` / `#failure`; the display label is never used as identity. - **Focus retention.** Tab + Enter on the Material node, then the primary focus must still be a descendant of the node's `Card`. -## Checks actually run +## Checks actually run (landing, after merging main) ``` dart format --output=none --set-exit-if-changed lib/features/graph/widgets \ test/features/graph/widgets tool/graph_node_probe.dart # 0 changed, exit 0 +flutter pub get # dependencies resolved flutter test test/features/graph/widgets # 13 passed -flutter test # 460 passed +flutter test test/features/graph # 113 passed +flutter test # 526 passed flutter analyze # No issues found! flutter build web -t tool/graph_node_probe.dart --release # ✓ Built build/web PROBE_VARIANT=material PROBE_SCHEME=dark node tool/graph_node_probe.mjs # passed, 6 captures PROBE_VARIANT=material PROBE_SCHEME=light node tool/graph_node_probe.mjs # passed, 6 captures PROBE_VARIANT=cupertino PROBE_SCHEME=dark node tool/graph_node_probe.mjs # passed, 6 captures PROBE_VARIANT=cupertino PROBE_SCHEME=light node tool/graph_node_probe.mjs # passed, 6 captures +flutter build web --release # ✓ app bundle restored ``` +The whole-suite count is 526 after `main` brought in the changes viewer and +routed-edge tests; the earlier figure of 460 was measured before that merge. + The runner asserts the initial labels (`Selected: build`, `plan`, `build`, `running`, `Success`, `Failure`), that exactly the `build` node carries `aria-current="true"` (Flutter web maps `Semantics(selected:)` to `aria-current`, @@ -109,26 +115,29 @@ not `aria-selected` — review note 5), that clicking `plan` and `Success` yield exactly `Selected: plan` and `Selected: #success`, and that the selected `aria-current` moves to `plan`. -## Browser evidence (current) +## Browser evidence (landing, current) -Real headless Chrome, loopback fixture only, 390×844 phone and 1280×800 desktop; -dark is Chrome's default scheme, light uses `prefers-color-scheme: light`. +Real headless Chrome, loopback fixture only, 390×844 phone and 1280×800 desktop. +The Material fixture now supplies a stock dark theme (`darkTheme` + +`themeMode.system`), so `PROBE_SCHEME=dark` and `=light` are genuinely different +renders (phone PNG SHA-256 `ac6272fd…` versus `c603c119…`); Cupertino follows the +platform scheme (`3e39555f…` versus `1f40f8b5…`). The runner writes +`material-nodes-*.png`, `light-material-nodes-*.png`, `cupertino-nodes-*.png` and +`light-cupertino-nodes-*.png`, plus `-long-1x-crop.png` / `-long-2x-crop.png`; +the shared copies below use a `land-p2-node-` prefix. -- `/Users/alan/.local/share/pipelines/data/artifacts/64/public/p2-node-fix-material-dark-phone.png` -- `.../p2-node-fix-material-light-phone.png` -- `.../p2-node-fix-material-dark-desktop.png` -- `.../p2-node-fix-material-long-2x-crop.png` (2x enlargement of the wrapped 2x node) -- `.../p2-node-fix-material-long-1x-crop.png` -- `.../p2-node-fix-material-selected-plan.png` -- `.../p2-node-fix-cupertino-dark-phone.png` -- `.../p2-node-fix-cupertino-light-phone.png` -- `.../p2-node-fix-cupertino-dark-desktop.png` -- `.../p2-node-fix-cupertino-long-2x-crop.png` -- `.../p2-node-fix-cupertino-selected-terminal.png` +- `/Users/alan/.local/share/pipelines/data/artifacts/64/public/land-p2-node-material-dark-phone.png` +- `.../land-p2-node-material-light-phone.png` +- `.../land-p2-node-material-dark-long-2x-crop.png` +- `.../land-p2-node-cupertino-dark-phone.png` +- `.../land-p2-node-cupertino-light-phone.png` +- `.../land-p2-node-cupertino-dark-long-2x-crop.png` - Runner: `.../public/graph_node_probe.mjs` (same file as `tool/graph_node_probe.mjs`) -The visit-1 captures (`material-nodes-*.png`, `cupertino-nodes-*.png`) and the UI -review crops are superseded by this set; they are kept only as history. +The visit-2 `p2-node-fix-material-dark-*` captures were the default light theme +with a "dark" name because the fixture had no dark theme; they are history only, +as are the visit-1 `material-nodes-*.png` / `cupertino-nodes-*.png` set and the +UI-review crops. Pixel measurements of the current 2x crops (crops are 2x, 8 logical px margin): @@ -142,10 +151,10 @@ x 16–316, y 16–200 container, and Cupertino ink x 59–264, y 59–164. No glyph ink enters a corner band or crosses the visible boundary in either scaling; the previous outline crossing is gone. -Inspected captures: Material shows outlined node bodies, a visibly filled -selected node, `running` only on `build`, and no status on either terminal; -Cupertino shows a tinted body for every unselected node and a filled selected -node in both light and dark. +Inspected captures: Material shows outlined node bodies and a visibly filled +selected node in real light and dark, `running` only on `build`, and no status on +either terminal; Cupertino shows a tinted body for every unselected node and a +filled selected node in both schemes. ## Honest limits @@ -170,8 +179,9 @@ node in both light and dark. - **No composition.** No canvas, layout invocation, edge painter, visit menu, shell registration or `main.dart` wiring: the widget is still not visible in the app. -- **Not committed.** This stage forbids commit/push/deploy; the paths stay - untracked on `flutter/p2-node-widget` for Review and Land. +- **State of the branch.** The six paths are committed on + `flutter/p2-node-widget` and `main` is merged in with no conflicts; the server + performs the landing and the post-landing ancestry check. - **Fixture-only browser evidence**: no Pipelines server, real run, authentication change, deployment or production data. - **Mobile unverified**: web test/analyze/build only; no Android/iOS build, diff --git a/app/tool/graph_node_probe.dart b/app/tool/graph_node_probe.dart index ff94f501..46c07f9f 100644 --- a/app/tool/graph_node_probe.dart +++ b/app/tool/graph_node_probe.dart @@ -77,6 +77,13 @@ void main() { ? CupertinoApp(home: const _Probe(cupertino: true)) : MaterialApp( theme: ThemeData(platform: TargetPlatform.android), + // Stock dark theme so the forced `prefers-color-scheme` capture is + // a real dark render rather than a duplicate light one. + darkTheme: ThemeData( + platform: TargetPlatform.android, + brightness: Brightness.dark, + ), + themeMode: ThemeMode.system, home: const _Probe(cupertino: false), ), );