kasy-cli 1.38.0 → 1.39.0

package/templates/firebase/lib/components/kasy_text_field.dart

@@ -29,7 +29,16 @@ class KasyTextField extends StatefulWidget {
   /// changing this value grows or shrinks the visible box on every platform.
   /// Matches the medium [KasyButton] height (45) so fields, the DatePicker
   /// trigger and the primary action all share one control height.
-  static const double singleLineHeight = 41;
+  static const double singleLineHeight = 45;
+
+  /// The single-line field renders its text at a fixed size and a *forced* line
+  /// box (see the [StrutStyle] on the inner field) so the box height is the same
+  /// on every renderer and breakpoint. Flutter web (CanvasKit) and native
+  /// otherwise disagree on a font's intrinsic line metrics by ~1px, and since
+  /// the box height is `text line + padding`, that variance would leak into the
+  /// visible height. Forcing the line to [fieldLineHeight] removes it entirely.
+  static const double fieldFontSize = 15;
+  static const double fieldLineHeight = 23;
 
   final TextEditingController? controller;
   final FocusNode? focusNode;
@@ -301,7 +310,10 @@ class _KasyTextFieldState extends State<KasyTextField> {
     // padding. So to hit [singleLineHeight] we back out the padding from it
     // (subtract one text line, halve). This is the only lever that actually
     // stretches the visible box — constraints/SizedBox just pad around it.
-    const double singleLineTextHeight = 19;
+    // The text line is forced to exactly [fieldLineHeight] (see the strut on the
+    // inner field), so this is deterministic on every renderer/platform:
+    // box = fieldLineHeight + 2×padding = singleLineHeight, always (45 → 11px).
+    const double singleLineTextHeight = KasyTextField.fieldLineHeight;
     final double singleLineVerticalPadding =
         ((KasyTextField.singleLineHeight - singleLineTextHeight) / 2)
             .clamp(0.0, 60.0);
@@ -487,11 +499,14 @@ class _KasyTextFieldState extends State<KasyTextField> {
 
     final Color fieldTextColor = dimDisabled(context.colors.onSurface);
     final TextStyle fieldTextStyle =
-        context.textTheme.bodyLarge?.copyWith(
-          color: fieldTextColor,
-          fontSize: 15,
-        ) ??
-        TextStyle(fontSize: 15, color: fieldTextColor);
+        (context.textTheme.bodyLarge ?? const TextStyle()).copyWith(
+      color: fieldTextColor,
+      fontSize: KasyTextField.fieldFontSize,
+      // Pin the line-height so the text box is a fixed [fieldLineHeight]px;
+      // paired with the forced strut on the field below, this makes the control
+      // height identical on every renderer (web CanvasKit vs native) and size.
+      height: KasyTextField.fieldLineHeight / KasyTextField.fieldFontSize,
+    );
     final InputDecoration decoration = InputDecoration(
       isDense: true,
       hintText: widget.hint,
@@ -583,6 +598,13 @@ class _KasyTextFieldState extends State<KasyTextField> {
       maxLength: widget.maxLength,
       buildCounter: hasCounter ? _hideInputCounter : null,
       style: fieldTextStyle,
+      // Force the line box to exactly [fieldLineHeight] regardless of the font's
+      // intrinsic metrics, so the field is the same height on every renderer
+      // (web CanvasKit and native disagree by ~1px otherwise) and breakpoint.
+      strutStyle: StrutStyle.fromTextStyle(
+        fieldTextStyle,
+        forceStrutHeight: true,
+      ),
       decoration: decoration,
       enableInteractiveSelection: widget.enableInteractiveSelection,
     );

package/templates/firebase/lib/core/bottom_menu/bottom_menu.dart

@@ -125,26 +125,35 @@ class BottomMenu extends StatelessWidget {
       },
       child: ResponsiveLayout(
         small: Consumer(
-          builder: (context, ref, _) {
+          // The scaffold is passed as `child` so it is built ONCE and reused
+          // across rebuilds of this Consumer. Toggling the setting below must
+          // NOT rebuild BartScaffold: if it did, Bart's MenuRouter (an
+          // InheritedWidget) re-runs its constructor and snaps the highlighted
+          // tab back to `initialRoute` — a value captured at mount, so possibly
+          // Home — even while the nested navigator still shows the current tab
+          // (the bottom bar marked "Início" while sitting on Settings).
+          child: NotificationListener<ScrollUpdateNotification>(
+            onNotification: (notification) {
+              KasyChromeVisibility.instance.handleScrollUpdate(notification);
+              return false; // let the notification keep bubbling
+            },
+            child: bart.BartScaffold(
+              routesBuilder: subRoutes,
+              bottomBar: kasyPaddedSurfaceBottomBar(),
+              initialRoute: resolvedInitialRoute,
+              showBottomBarOnStart: showBottomBarOnStart,
+              scaffoldOptions: scaffoldOptions,
+              onRouteChanged: _rememberActiveTab,
+            ),
+          ),
+          builder: (context, ref, child) {
             // Watching the provider here keeps the persisted on/off setting in
-            // sync with the controller, and scopes scroll tracking to the
-            // mobile shell only (detail screens push on the root navigator, so
-            // their scrolls never reach this listener).
+            // sync with the controller (the notifier writes the effective value
+            // into KasyChromeVisibility.instance.enabled), and scopes it to the
+            // mobile shell only. Returning the cached `child` keeps the scaffold
+            // out of this rebuild.
             ref.watch(hideChromeOnScrollProvider);
-            return NotificationListener<ScrollUpdateNotification>(
-              onNotification: (notification) {
-                KasyChromeVisibility.instance.handleScrollUpdate(notification);
-                return false; // let the notification keep bubbling
-              },
-              child: bart.BartScaffold(
-                routesBuilder: subRoutes,
-                bottomBar: kasyPaddedSurfaceBottomBar(),
-                initialRoute: resolvedInitialRoute,
-                showBottomBarOnStart: showBottomBarOnStart,
-                scaffoldOptions: scaffoldOptions,
-                onRouteChanged: _rememberActiveTab,
-              ),
-            );
+            return child!;
           },
         ),
         medium: connectedScaffold(),

package/templates/firebase/lib/core/bottom_menu/web_content_wrapper.dart

@@ -1,6 +1,7 @@
 import 'package:flutter/material.dart';
-import 'package:kasy_kit/components/kasy_web_header.dart';
-import 'package:kasy_kit/core/chrome/web_header_scope.dart';
+import 'package:kasy_kit/components/kasy_app_bar.dart';
+import 'package:kasy_kit/core/chrome/app_bar_config.dart';
+import 'package:kasy_kit/core/chrome/app_bar_scope.dart';
 import 'package:kasy_kit/core/theme/theme.dart';
 import 'package:kasy_kit/core/widgets/responsive_layout.dart';
 import 'package:kasy_kit/features/notifications/ui/widgets/web_notifications_bell.dart';
@@ -14,9 +15,10 @@ import 'package:kasy_kit/features/notifications/ui/widgets/web_notifications_bel
 /// always jumps to the most recently mounted page.
 FocusNode? kasyContentFocusTarget;
 
-/// On desktop (≥ [DeviceType.large]) this puts the [KasyWebHeader] at the top of
-/// the content area, above the routed page. On phone/tablet it is transparent
-/// (returns the page untouched) — there the page keeps its own [KasyAppBar].
+/// On desktop (≥ [DeviceType.large]) this puts the [KasyAppBar.application] at the
+/// top of the content area, above the routed page. On phone/tablet it is
+/// transparent (returns the page untouched) — there the page keeps its own
+/// [KasyAppBar].
 ///
 /// Wrap each routed page with this in the bottom router so the header is present
 /// across navigation without touching individual pages.
@@ -65,10 +67,10 @@ class _WebContentWrapperState extends State<WebContentWrapper> {
     // header (2) → content (3). Each block is its own FocusTraversalGroup so its
     // internal order stays natural (e.g. header: search → theme → … → create).
     //
-    // KasyWebHeaderScope marks this subtree as "has a web header above", so the
-    // page-level KasyAppBar hides on desktop here (the header owns the chrome).
-    // Outside this scope (full-screen pushed routes) the app bar stays visible.
-    return KasyWebHeaderScope(
+    // KasyAppBarScope marks this subtree as "has an application bar above", so the
+    // page-level KasyAppBar hides on desktop here (the application bar owns the
+    // chrome). Outside this scope (full-screen pushed routes) the bar stays visible.
+    return KasyAppBarScope(
       child: ColoredBox(
         color: context.colors.background,
         child: Column(
@@ -79,7 +81,7 @@ class _WebContentWrapperState extends State<WebContentWrapper> {
           FocusTraversalOrder(
             order: const NumericFocusOrder(2),
             child: FocusTraversalGroup(
-              child: KasyWebHeader(
+              child: KasyAppBar.application(
                 onToggleTheme: () => ThemeProvider.of(context).toggle(),
                 notifications: const WebNotificationsBell(),
                 onCreate: () {},

package/templates/firebase/lib/core/chrome/app_bar_config.dart

@@ -0,0 +1,214 @@
+import 'package:flutter/widgets.dart';
+import 'package:kasy_kit/components/kasy_avatar_presets.dart';
+
+/// Declares what the desktop application bar ([KasyAppBar.application]) shows for
+/// a given screen.
+///
+/// The shell (`WebContentWrapper`) renders one application bar above all content
+/// and seeds it with an app-wide default. A screen overrides that default by
+/// wrapping its body in a [KasyAppBarConfigurator] (or, for screens built on
+/// `KasyOverlayScaffold`, by passing `applicationBar:`). So each screen decides
+/// its own desktop chrome — search here, just notifications there — instead of
+/// every screen sharing one fixed bar.
+///
+/// Each element has a `showX` flag (presets toggle these) plus the data/callbacks
+/// it needs when shown. A bare [KasyAppBarConfig] mirrors the app default.
+@immutable
+class KasyAppBarConfig {
+  // Search ------------------------------------------------------------------
+  final bool showSearch;
+  final TextEditingController? searchController;
+  final String searchHint;
+  final ValueChanged<String>? onSearchChanged;
+  final ValueChanged<String>? onSearchSubmitted;
+
+  // Theme toggle ------------------------------------------------------------
+  final bool showThemeToggle;
+  final VoidCallback? onToggleTheme;
+
+  // Notifications -----------------------------------------------------------
+  final bool showNotifications;
+
+  /// Custom notifications control (e.g. a data-aware bell). Replaces the built-in
+  /// bell when set and [showNotifications] is true.
+  final Widget? notifications;
+  final VoidCallback? onNotifications;
+  final bool showNotificationBadge;
+
+  // Create ------------------------------------------------------------------
+  final bool showCreate;
+  final String createLabel;
+  final VoidCallback? onCreate;
+
+  // Profile -----------------------------------------------------------------
+  final bool showAvatar;
+  final Widget? avatar;
+  final KasyAvatarGradientData? avatarGradient;
+  final VoidCallback? onAvatarTap;
+
+  /// Full control: every element shown by default (matches the app shell). Set a
+  /// `showX` to false to drop that element, or pass data/callbacks to wire it.
+  const KasyAppBarConfig({
+    this.showSearch = true,
+    this.searchController,
+    this.searchHint = 'Search...',
+    this.onSearchChanged,
+    this.onSearchSubmitted,
+    this.showThemeToggle = true,
+    this.onToggleTheme,
+    this.showNotifications = true,
+    this.notifications,
+    this.onNotifications,
+    this.showNotificationBadge = false,
+    this.showCreate = true,
+    this.createLabel = 'Create',
+    this.onCreate,
+    this.showAvatar = false,
+    this.avatar,
+    this.avatarGradient,
+    this.onAvatarTap,
+  });
+
+  /// Preset: only the theme toggle — the quietest bar (settings-style screens).
+  const KasyAppBarConfig.minimal({VoidCallback? onToggleTheme})
+      : this(
+          showSearch: false,
+          showThemeToggle: true,
+          onToggleTheme: onToggleTheme,
+          showNotifications: false,
+          showCreate: false,
+          showAvatar: false,
+        );
+
+  /// Preset: search + theme, no quick-create (browse / list screens).
+  const KasyAppBarConfig.search({
+    TextEditingController? controller,
+    String hint = 'Search...',
+    ValueChanged<String>? onChanged,
+    ValueChanged<String>? onSubmitted,
+    VoidCallback? onToggleTheme,
+  }) : this(
+          showSearch: true,
+          searchController: controller,
+          searchHint: hint,
+          onSearchChanged: onChanged,
+          onSearchSubmitted: onSubmitted,
+          showThemeToggle: true,
+          onToggleTheme: onToggleTheme,
+          showNotifications: false,
+          showCreate: false,
+          showAvatar: false,
+        );
+
+  /// Show ONLY the listed elements (everything else hidden), keeping each one's
+  /// data and callbacks from the shell default — so a screen can say "just the
+  /// notifications and theme here" without rebuilding the bell or theme wiring.
+  ///
+  /// ```dart
+  /// configure: (bar) => bar.only(search: true),            // browse screen
+  /// configure: (bar) => bar.only(notifications: true, themeToggle: true),
+  /// ```
+  KasyAppBarConfig only({
+    bool search = false,
+    bool themeToggle = false,
+    bool notifications = false,
+    bool create = false,
+    bool avatar = false,
+  }) {
+    return copyWith(
+      showSearch: search,
+      showThemeToggle: themeToggle,
+      showNotifications: notifications,
+      showCreate: create,
+      showAvatar: avatar,
+    );
+  }
+
+  /// Copy with selective overrides — handy for adapting the shell default.
+  KasyAppBarConfig copyWith({
+    bool? showSearch,
+    TextEditingController? searchController,
+    String? searchHint,
+    ValueChanged<String>? onSearchChanged,
+    ValueChanged<String>? onSearchSubmitted,
+    bool? showThemeToggle,
+    VoidCallback? onToggleTheme,
+    bool? showNotifications,
+    Widget? notifications,
+    VoidCallback? onNotifications,
+    bool? showNotificationBadge,
+    bool? showCreate,
+    String? createLabel,
+    VoidCallback? onCreate,
+    bool? showAvatar,
+    Widget? avatar,
+    KasyAvatarGradientData? avatarGradient,
+    VoidCallback? onAvatarTap,
+  }) {
+    return KasyAppBarConfig(
+      showSearch: showSearch ?? this.showSearch,
+      searchController: searchController ?? this.searchController,
+      searchHint: searchHint ?? this.searchHint,
+      onSearchChanged: onSearchChanged ?? this.onSearchChanged,
+      onSearchSubmitted: onSearchSubmitted ?? this.onSearchSubmitted,
+      showThemeToggle: showThemeToggle ?? this.showThemeToggle,
+      onToggleTheme: onToggleTheme ?? this.onToggleTheme,
+      showNotifications: showNotifications ?? this.showNotifications,
+      notifications: notifications ?? this.notifications,
+      onNotifications: onNotifications ?? this.onNotifications,
+      showNotificationBadge: showNotificationBadge ?? this.showNotificationBadge,
+      showCreate: showCreate ?? this.showCreate,
+      createLabel: createLabel ?? this.createLabel,
+      onCreate: onCreate ?? this.onCreate,
+      showAvatar: showAvatar ?? this.showAvatar,
+      avatar: avatar ?? this.avatar,
+      avatarGradient: avatarGradient ?? this.avatarGradient,
+      onAvatarTap: onAvatarTap ?? this.onAvatarTap,
+    );
+  }
+
+  @override
+  bool operator ==(Object other) {
+    return other is KasyAppBarConfig &&
+        other.showSearch == showSearch &&
+        other.searchController == searchController &&
+        other.searchHint == searchHint &&
+        other.onSearchChanged == onSearchChanged &&
+        other.onSearchSubmitted == onSearchSubmitted &&
+        other.showThemeToggle == showThemeToggle &&
+        other.onToggleTheme == onToggleTheme &&
+        other.showNotifications == showNotifications &&
+        other.notifications == notifications &&
+        other.onNotifications == onNotifications &&
+        other.showNotificationBadge == showNotificationBadge &&
+        other.showCreate == showCreate &&
+        other.createLabel == createLabel &&
+        other.onCreate == onCreate &&
+        other.showAvatar == showAvatar &&
+        other.avatar == avatar &&
+        other.avatarGradient == avatarGradient &&
+        other.onAvatarTap == onAvatarTap;
+  }
+
+  @override
+  int get hashCode => Object.hashAll(<Object?>[
+        showSearch,
+        searchController,
+        searchHint,
+        onSearchChanged,
+        onSearchSubmitted,
+        showThemeToggle,
+        onToggleTheme,
+        showNotifications,
+        notifications,
+        onNotifications,
+        showNotificationBadge,
+        showCreate,
+        createLabel,
+        onCreate,
+        showAvatar,
+        avatar,
+        avatarGradient,
+        onAvatarTap,
+      ]);
+}

package/templates/firebase/lib/core/chrome/app_bar_scope.dart

@@ -0,0 +1,102 @@
+import 'package:flutter/widgets.dart';
+import 'package:kasy_kit/core/chrome/app_bar_config.dart';
+
+/// Transforms the shell's default application-bar config into a screen's version.
+/// Receives the shell default (with its wired bell, theme toggle, etc.) so a
+/// screen only toggles/overrides what it needs and inherits the rest.
+typedef KasyAppBarConfigure = KasyAppBarConfig Function(KasyAppBarConfig base);
+
+/// Marks the subtree that sits BELOW the desktop application bar
+/// ([KasyAppBar.application]) — i.e. the shell content area, provided by
+/// [WebContentWrapper] — and carries the config the bar renders from.
+///
+/// Two jobs:
+/// 1. Presence ([of]) lets the page-level [KasyAppBar] hide on desktop INSIDE the
+///    shell (where the application bar owns the chrome) but stay visible OUTSIDE
+///    it (a full-screen pushed route), so the back button is never lost.
+/// 2. [config] is the live config the bar listens to; [defaultConfig] is the
+///    shell's app-wide default. A [KasyAppBarConfigurator] in the routed page
+///    publishes `configure(defaultConfig)` into [config] to override the bar for
+///    that screen.
+class KasyAppBarScope extends InheritedWidget {
+  /// Live config the application bar renders from. The bar listens; screens write.
+  final ValueNotifier<KasyAppBarConfig> config;
+
+  /// The shell's app-wide default — the starting point screen overrides build on.
+  final KasyAppBarConfig defaultConfig;
+
+  const KasyAppBarScope({
+    super.key,
+    required this.config,
+    required this.defaultConfig,
+    required super.child,
+  });
+
+  /// True when a [KasyAppBarScope] is an ancestor (no rebuild dependency —
+  /// presence is fixed for a given subtree).
+  static bool of(BuildContext context) => maybeOf(context) != null;
+
+  /// The nearest scope, or null outside the shell (e.g. full-screen routes).
+  static KasyAppBarScope? maybeOf(BuildContext context) =>
+      context.getInheritedWidgetOfExactType<KasyAppBarScope>();
+
+  @override
+  bool updateShouldNotify(KasyAppBarScope oldWidget) =>
+      config != oldWidget.config || defaultConfig != oldWidget.defaultConfig;
+}
+
+/// Wrap a routed page's body with this to override the desktop application bar
+/// for that screen. On phone/tablet (no scope above) it is a transparent
+/// pass-through, so it is always safe to add.
+///
+/// ```dart
+/// KasyAppBarConfigurator(
+///   configure: (bar) => bar.only(search: true),
+///   child: MyScreen(),
+/// )
+/// ```
+class KasyAppBarConfigurator extends StatefulWidget {
+  /// How this screen adapts the shell default. Return [base] unchanged to keep
+  /// the default, or e.g. `base.only(...)` / `base.copyWith(...)`.
+  final KasyAppBarConfigure configure;
+  final Widget child;
+
+  const KasyAppBarConfigurator({
+    super.key,
+    required this.configure,
+    required this.child,
+  });
+
+  @override
+  State<KasyAppBarConfigurator> createState() => _KasyAppBarConfiguratorState();
+}
+
+class _KasyAppBarConfiguratorState extends State<KasyAppBarConfigurator> {
+  void _publish() {
+    if (!mounted) return;
+    final KasyAppBarScope? scope = KasyAppBarScope.maybeOf(context);
+    if (scope == null) return; // phone/tablet: no application bar to configure.
+    // Always build from the ORIGINAL default (not the current value), so the
+    // override is stable across rebuilds. The setter is a no-op when the result
+    // is unchanged (==), so an inline-built config does not churn the bar.
+    //
+    // Published post-frame: the bar (a sibling above this page in the shell
+    // Column) has already built this frame, so it picks the override up next.
+    scope.config.value = widget.configure(scope.defaultConfig);
+  }
+
+  @override
+  void didChangeDependencies() {
+    super.didChangeDependencies();
+    WidgetsBinding.instance.addPostFrameCallback((_) => _publish());
+  }
+
+  @override
+  void didUpdateWidget(covariant KasyAppBarConfigurator oldWidget) {
+    super.didUpdateWidget(oldWidget);
+    WidgetsBinding.instance.addPostFrameCallback((_) => _publish());
+  }
+
+  @override
+  Widget build(BuildContext context) => widget.child;
+}

package/templates/firebase/lib/core/data/api/user_api.dart

@@ -78,6 +78,17 @@ class UserApi {
         'authFunctions-deleteUserAccount',
       );
       await callable.call();
+    } on FirebaseFunctionsException catch (err, stacktrace) {
+      // Surface the REAL cause in the logs instead of a generic message, so a
+      // failed deletion is diagnosable at a glance:
+      //   code 'not-found'      → the function isn't deployed yet (run a deploy)
+      //   code 'unauthenticated'→ the user's token didn't reach the function
+      //   code 'internal'       → the function ran but threw (see its own logs)
+      _logger.e(
+        "delete user error [${err.code}] ${err.message}",
+        stackTrace: stacktrace,
+      );
+      throw ApiError(message: err.message ?? "Error while deleting user");
     } catch (err, stacktrace) {
       _logger.e("delete user error $err", stackTrace: stacktrace);
       throw ApiError(message: "Error while deleting user");

package/templates/firebase/lib/core/dev_inspector/dev_inspector_service.dart

@@ -6,7 +6,15 @@ import 'package:kasy_kit/core/dev_inspector/dev_inspector_info.dart';
 class DevInspectorService {
   DevInspectorService._();
 
-  static const _screenRegex = r'(Page|Screen|Route|View)$';
+  static const _screenRegex = r'(Page|Screen|Route|View|Tab|Shell)$';
+
+  /// Strips generic type arguments so `PopupMenuItem<bool>` matches against
+  /// `PopupMenuItem`, `Router<Object>` against `Router`, etc. Set / regex
+  /// lookups all compare against this base name.
+  static String _baseName(String typeName) {
+    final i = typeName.indexOf('<');
+    return i < 0 ? typeName : typeName.substring(0, i);
+  }
 
   // Widgets we refuse to return — even after climbing.
   static const _skipSet = <String>{
@@ -64,9 +72,32 @@ class DevInspectorService {
 
     // Context propagation
     'Theme', 'DefaultTextStyle', 'IconTheme', 'IconButtonTheme',
+    'CupertinoTheme', 'InheritedCupertinoTheme', 'CupertinoUserInterfaceLevel',
+    'ResponsiveTextTheme',
     'Localizations', 'Directionality', 'Title',
     'DefaultSelectionStyle', 'SelectionContainer', 'AnnotatedRegion',
 
+    // App-root / navigation / overlay scaffolding (framework + go_router +
+    // project shell). Selecting these is never useful — they're plumbing.
+    'Router', 'InheritedGoRouter', 'GoRouterStateRegistryScope',
+    'StatefulNavigationShell', 'Navigator', 'Overlay', 'OverlayPortal',
+    'CustomMultiChildLayout', 'CustomSingleChildLayout', 'LayoutId',
+    'ScaffoldMessenger', 'TapRegion', 'TapRegionSurface',
+    'ShortcutRegistrar', 'DefaultTextEditingShortcuts', 'ExcludeFocus',
+    'FocusVisibility', 'Initializer',
+
+    // Framework app-root + dev wrappers (the engine's View/RootWidget, the app
+    // widget, Riverpod/i18n providers, and the device_preview chrome used on
+    // web). None is ever a meaningful selection or a "screen".
+    'RootWidget', 'View', 'RawView', 'ViewAnchor',
+    'WidgetsApp', 'MaterialApp', 'CupertinoApp', 'MyApp',
+    'RootRestorationScope', 'SharedAppData',
+    'TranslationProvider', 'InheritedLocaleData',
+    'ProviderScope', 'UncontrolledProviderScope',
+    'ThemeProvider', 'ChangeNotifierProvider', 'MediaQueryObserver',
+    'WebDevicePreview', 'DevicePreview', 'DeviceFrame', 'VirtualKeyboard',
+    'RotatedBox',
+
     // Routing / storage
     'KeyedSubtree', 'AutomaticKeepAlive', 'KeepAlive', 'TickerMode',
     'Offstage', 'PageStorage', 'RestorationScope',
@@ -93,12 +124,8 @@ class DevInspectorService {
     'RichText', 'RawMaterialButton',
   };
 
-  static bool _shouldClimbPast(String typeName) {
-    if (_climbPastSet.contains(typeName)) return true;
-    return typeName.startsWith('NotificationListener<') ||
-        typeName.startsWith('Listener<') ||
-        typeName.startsWith('Builder<');
-  }
+  static bool _shouldClimbPast(String typeName) =>
+      _climbPastSet.contains(_baseName(typeName));
 
   // Used by ancestor-list builders (kept as-is — affects displayed tree only).
   static bool _isGenericUi(String typeName) => _shouldClimbPast(typeName);
@@ -125,11 +152,16 @@ class DevInspectorService {
     '_PrimaryScrollControllerScope',
     '_TapRegionRegistry', '_TapRegionSurface',
     '_KeyedSubtree',
+    // Semantics / pointer / scroll internals that wrap every tappable widget.
+    // Stopping here yields a useless `_GestureSemantics`/`_ScrollableScope`
+    // instead of the real widget.
+    '_GestureSemantics', '_InkResponseStateWidget', '_ScrollableScope',
+    '_RenderScrollSemantics',
   };
 
   static bool _shouldSkip(String typeName) {
-    if (_skipSet.contains(typeName)) return true;
-    return _privateFrameworkSet.contains(typeName);
+    final base = _baseName(typeName);
+    return _skipSet.contains(base) || _privateFrameworkSet.contains(base);
   }
 
   static List<String> _extractProperties(Element element) {
@@ -182,18 +214,26 @@ class DevInspectorService {
       return routeName;
     }
 
-    final privateAwareAncestors = _extractAncestors(element, includePrivate: true);
+    // Scan innermost-first so the most specific screen wins (e.g. the active
+    // `AdminUsersTab` rather than the surrounding `AdminShell`).
+    final privateAwareAncestors = _extractAncestors(
+      element,
+      includePrivate: true,
+    );
     final regex = RegExp('^_?[A-Za-z0-9]+$_screenRegex');
-    for (final type in privateAwareAncestors.reversed) {
+    for (final type in privateAwareAncestors) {
       if (regex.hasMatch(type)) return _sanitizeType(type);
     }
-    for (final type in ancestors.reversed) {
-      if (RegExp(_screenRegex).hasMatch(type)) return _sanitizeType(type);
+    for (final type in ancestors) {
+      if (regex.hasMatch(type)) return _sanitizeType(type);
     }
     return null;
   }
 
-  static String? _extractSemanticWidget(String widgetType, List<String> ancestors) {
+  static String? _extractSemanticWidget(
+    String widgetType,
+    List<String> ancestors,
+  ) {
     final chain = <String>[widgetType, ...ancestors];
     final featureRegex = RegExp(
       r'(Page|Screen|Card|Tile|Item|Section|Panel|Dialog|Modal|Header|Footer|Widget|Component)$',
@@ -203,7 +243,7 @@ class DevInspectorService {
     for (final type in chain) {
       if (_shouldSkip(type)) continue;
       if (_shouldClimbPast(type)) continue;
-      if (featureRegex.hasMatch(type)) return type;
+      if (featureRegex.hasMatch(_baseName(type))) return type;
     }
 
     // 2) Fallback to first non-generic non-skipped widget.