reis-mobile 0.3.5

package/skills/flutter-change-notifier/SKILL.md

@@ -0,0 +1,138 @@
+---
+name: flutter-change-notifier
+description: Implements state management with ChangeNotifier and Provider in Flutter. Use when setting up ChangeNotifier models, providing them to the widget tree, consuming state with Consumer or Provider.of, or optimizing rebuilds.
+routing: manual
+stacks: [flutter]
+source: https://github.com/evanca/flutter-ai-rules
+license: MIT
+---
+
+# Flutter ChangeNotifier Skill
+
+This skill defines how to correctly use `ChangeNotifier` with the `provider` package for state management in Flutter.
+
+---
+
+## 1. Model
+
+Extend `ChangeNotifier` to manage state. Keep internal state **private** and expose **unmodifiable views**. Call `notifyListeners()` on every state change.
+
+```dart
+class CartModel extends ChangeNotifier {
+  final List<Item> _items = [];
+
+  UnmodifiableListView<Item> get items => UnmodifiableListView(_items);
+
+  void add(Item item) {
+    _items.add(item);
+    notifyListeners();
+  }
+
+  void removeAll() {
+    _items.clear();
+    notifyListeners();
+  }
+}
+```
+
+- Place shared state **above** the widgets that use it in the widget tree.
+- Never directly mutate widgets or call methods on them to change state — rebuild widgets with new data instead.
+
+---
+
+## 2. Providing the Model
+
+```dart
+ChangeNotifierProvider(
+  create: (context) => CartModel(),
+  child: MyApp(),
+)
+```
+
+- `ChangeNotifierProvider` **automatically disposes** of the model when it is no longer needed.
+- Use `MultiProvider` when you need to provide multiple models:
+
+```dart
+MultiProvider(
+  providers: [
+    ChangeNotifierProvider(create: (_) => CartModel()),
+    ChangeNotifierProvider(create: (_) => UserModel()),
+  ],
+  child: MyApp(),
+)
+```
+
+---
+
+## 3. Consuming State
+
+### Consumer
+
+```dart
+Consumer<CartModel>(
+  builder: (context, cart, child) => Stack(
+    children: [
+      if (child != null) child,
+      Text('Total price: ${cart.totalPrice}'),
+    ],
+  ),
+  child: const SomeExpensiveWidget(), // rebuilt only once
+)
+```
+
+- Always specify the generic type (`Consumer<CartModel>`, not `Consumer`).
+- Use the `child` parameter to pass **widgets that don't depend on the model** — they are built once and reused.
+- Place `Consumer` widgets **as deep in the widget tree as possible** to minimize the scope of rebuilds:
+
+```dart
+HumongousWidget(
+  child: AnotherMonstrousWidget(
+    child: Consumer<CartModel>(
+      builder: (context, cart, child) {
+        return Text('Total price: ${cart.totalPrice}');
+      },
+    ),
+  ),
+)
+```
+
+### Provider.of with listen: false
+
+Use `Provider.of<T>(context, listen: false)` when you only need to **call methods** on the model, not react to state changes:
+
+```dart
+Provider.of<CartModel>(context, listen: false).removeAll();
+```
+
+---
+
+## 4. Optimization Rules
+
+- Do **not** wrap large widget subtrees in a `Consumer` if only a small part depends on the model.
+- Avoid rebuilding widgets unnecessarily — structure your widget tree and provider usage carefully.
+- Use `listen: false` in callbacks (e.g., `onPressed`) where you trigger actions but don't need rebuilds.
+
+---
+
+## 5. Testing
+
+Write **unit tests** for your `ChangeNotifier` models to verify state changes and notifications:
+
+```dart
+test('adding item updates total', () {
+  final cart = CartModel();
+  var notified = false;
+  cart.addListener(() => notified = true);
+
+  cart.add(Item('Book'));
+
+  expect(cart.items.length, 1);
+  expect(notified, isTrue);
+});
+```
+
+---
+
+## References
+
+- [Flutter Website GitHub Repository](https://github.com/flutter/website)

package/skills/flutter-embedding-native-views/SKILL.md

@@ -0,0 +1,200 @@
+---
+name: flutter-embedding-native-views
+description: Embeds native Android, iOS, or macOS views into a Flutter app. Use when integrating complex native components like maps or web views.
+metadata:
+  model: models/gemini-3.1-pro-preview
+  last_modified: Thu, 12 Mar 2026 22:20:28 GMT
+routing: manual
+stacks: [flutter]
+source: https://github.com/flutter/skills
+license: BSD-3-Clause
+---
+# Integrating Platform Views and Web Content
+
+## Contents
+- [Platform Views Architecture](#platform-views-architecture)
+- [Web Embedding Architecture](#web-embedding-architecture)
+- [Workflow: Implementing Android Platform Views](#workflow-implementing-android-platform-views)
+- [Workflow: Implementing iOS Platform Views](#workflow-implementing-ios-platform-views)
+- [Workflow: Embedding Flutter in Web Applications](#workflow-embedding-flutter-in-web-applications)
+- [Examples](#examples)
+
+## Platform Views Architecture
+
+Platform Views allow embedding native views (Android, iOS, macOS) directly into a Flutter application, enabling the application of transforms, clips, and opacity from Dart.
+
+### Android Implementations (API 23+)
+Choose the appropriate implementation based on your performance and fidelity requirements:
+*   **Hybrid Composition:** Renders Flutter content into a texture and uses `SurfaceFlinger` to compose both. 
+    *   *Pros:* Best performance and fidelity for Android views.
+    *   *Cons:* Lowers overall application FPS. Certain Flutter widget transformations will not work.
+*   **Texture Layer (Texture Layer Hybrid Composition):** Renders Platform Views into a texture. Flutter draws them via the texture and renders its own content directly into a Surface.
+    *   *Pros:* Best performance for Flutter rendering. All transformations work correctly.
+    *   *Cons:* Quick scrolling (e.g., WebViews) can be janky. `SurfaceView` is problematic (breaks accessibility). Text magnifiers break unless Flutter is rendered into a `TextureView`.
+
+### iOS & macOS Implementations
+*   **iOS:** Uses Hybrid Composition exclusively. The native `UIView` is appended to the view hierarchy.
+    *   *Limitations:* `ShaderMask` and `ColorFiltered` widgets are not supported. `BackdropFilter` has composition limitations.
+*   **macOS:** Uses Hybrid Composition (`NSView`). 
+    *   *Limitations:* Not fully functional in current releases (e.g., gesture support is unavailable).
+
+### Performance Mitigation
+Mitigate performance drops during complex Dart animations by rendering a screenshot of the native view as a placeholder texture while the animation runs.
+
+## Web Embedding Architecture
+
+Embed Flutter into existing web applications (Vanilla JS, React, Angular, etc.) using either Full Page mode or Embedded (Multi-view) mode.
+
+*   **Full Page Mode:** Flutter takes over the entire browser window. Use an `iframe` if you need to constrain the Flutter app without modifying the Flutter bootstrap process.
+*   **Embedded Mode (Multi-view):** Render Flutter into specific HTML elements (`div`s). Requires `multiViewEnabled: true` during engine initialization.
+    *   Manage views from JavaScript using `app.addView()` and `app.removeView()`.
+    *   In Dart, replace `runApp` with `runWidget`.
+    *   Manage the dynamic list of views using `WidgetsBinding.instance.platformDispatcher.views` and render them using `ViewCollection` and `View` widgets.
+
+## Workflow: Implementing Android Platform Views
+
+Follow this sequential workflow to implement a Platform View on Android.
+
+**Task Progress:**
+- [ ] 1. Determine the composition mode (Hybrid vs. Texture Layer).
+- [ ] 2. Implement the Dart widget.
+- [ ] 3. Implement the native Android View and Factory.
+- [ ] 4. Register the Platform View in the Android host.
+- [ ] 5. Run validator -> review rendering -> fix manual invalidation issues.
+
+### 1. Dart Implementation
+If using **Hybrid Composition**, use `PlatformViewLink`, `AndroidViewSurface`, and `PlatformViewsService.initSurfaceAndroidView`.
+If using **Texture Layer**, use the `AndroidView` widget.
+
+### 2. Native Implementation
+Create a class implementing `io.flutter.plugin.platform.PlatformView` that returns your native `android.view.View`.
+Create a factory extending `PlatformViewFactory` to instantiate your view.
+
+### 3. Registration
+Register the factory in your `MainActivity.kt` (or plugin) using `flutterEngine.platformViewsController.registry.registerViewFactory`.
+
+*Note: If your native view uses `SurfaceView` or `SurfaceTexture`, manually call `invalidate` on the View or its parent when content changes, as they do not invalidate themselves automatically.*
+
+## Workflow: Implementing iOS Platform Views
+
+Follow this sequential workflow to implement a Platform View on iOS.
+
+**Task Progress:**
+- [ ] 1. Implement the Dart widget using `UiKitView`.
+- [ ] 2. Implement the native iOS View (`FlutterPlatformView`) and Factory (`FlutterPlatformViewFactory`).
+- [ ] 3. Register the Platform View in `AppDelegate.swift` or the plugin registrar.
+- [ ] 4. Run validator -> review composition limitations -> fix unsupported filters.
+
+## Workflow: Embedding Flutter in Web Applications
+
+Follow this sequential workflow to embed Flutter into an existing web DOM.
+
+**Task Progress:**
+- [ ] 1. Update `flutter_bootstrap.js` to enable multi-view.
+- [ ] 2. Update `main.dart` to use `runWidget` and `ViewCollection`.
+- [ ] 3. Implement JavaScript logic to add/remove host elements.
+- [ ] 4. Run validator -> review view constraints -> fix CSS conflicts.
+
+### 1. JavaScript Configuration
+In `flutter_bootstrap.js`, initialize the engine with `multiViewEnabled: true`.
+Use the returned `app` object to add views: `app.addView({ hostElement: document.getElementById('my-div') })`.
+
+### 2. Dart Configuration
+Replace `runApp()` with `runWidget()`.
+Create a root widget that listens to `WidgetsBindingObserver.didChangeMetrics`.
+Map over `WidgetsBinding.instance.platformDispatcher.views` to create a `View` widget for each attached `FlutterView`, and wrap them all in a `ViewCollection`.
+
+## Examples
+
+### Example: Android Texture Layer (Dart)
+```dart
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+
+class NativeAndroidView extends StatelessWidget {
+  @override
+  Widget build(BuildContext context) {
+    const String viewType = 'my_native_view';
+    final Map<String, dynamic> creationParams = <String, dynamic>{};
+
+    return AndroidView(
+      viewType: viewType,
+      layoutDirection: TextDirection.ltr,
+      creationParams: creationParams,
+      creationParamsCodec: const StandardMessageCodec(),
+    );
+  }
+}
+```
+
+### Example: Web Multi-View Initialization (JavaScript)
+```javascript
+_flutter.loader.load({
+  onEntrypointLoaded: async function(engineInitializer) {
+    let engine = await engineInitializer.initializeEngine({
+      multiViewEnabled: true,
+    });
+    let app = await engine.runApp();
+    
+    // Add a view to a specific DOM element
+    let viewId = app.addView({
+      hostElement: document.querySelector('#flutter-host-container'),
+      initialData: { customData: 'Hello from JS' }
+    });
+  }
+});
+```
+
+### Example: Web Multi-View Root Widget (Dart)
+```dart
+import 'dart:ui' show FlutterView;
+import 'package:flutter/widgets.dart';
+
+void main() {
+  runWidget(MultiViewApp(viewBuilder: (context) => const MyEmbeddedWidget()));
+}
+
+class MultiViewApp extends StatefulWidget {
+  final WidgetBuilder viewBuilder;
+  const MultiViewApp({super.key, required this.viewBuilder});
+
+  @override
+  State<MultiViewApp> createState() => _MultiViewAppState();
+}
+
+class _MultiViewAppState extends State<MultiViewApp> with WidgetsBindingObserver {
+  Map<Object, Widget> _views = {};
+
+  @override
+  void initState() {
+    super.initState();
+    WidgetsBinding.instance.addObserver(this);
+    _updateViews();
+  }
+
+  @override
+  void didChangeMetrics() => _updateViews();
+
+  void _updateViews() {
+    final newViews = <Object, Widget>{};
+    for (final FlutterView view in WidgetsBinding.instance.platformDispatcher.views) {
+      newViews[view.viewId] = _views[view.viewId] ?? View(
+        view: view,
+        child: Builder(builder: widget.viewBuilder),
+      );
+    }
+    setState(() => _views = newViews);
+  }
+
+  @override
+  void dispose() {
+    WidgetsBinding.instance.removeObserver(this);
+    super.dispose();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return ViewCollection(views: _views.values.toList(growable: false));
+  }
+}
+```

package/skills/flutter-errors/SKILL.md

@@ -0,0 +1,126 @@
+---
+name: flutter-errors
+description: Diagnoses and fixes common Flutter errors. Use when encountering layout errors (RenderFlex overflow, unbounded constraints, RenderBox not laid out), scroll errors, or setState-during-build errors.
+intents: [debug]
+stacks: [flutter]
+source: https://github.com/evanca/flutter-ai-rules
+license: MIT
+---
+
+# Flutter Errors Skill
+
+This skill provides solutions for the most common Flutter runtime and layout errors.
+
+---
+
+## RenderFlex Overflowed
+
+**Error:** `A RenderFlex overflowed by X pixels on the right/bottom.`
+
+**Cause:** A `Row` or `Column` contains children that are wider/taller than the available space.
+
+**Fix:** Wrap the overflowing child in `Flexible` or `Expanded`, or constrain its size:
+
+```dart
+Row(
+  children: [
+    Expanded(child: Text('Long text that might overflow')),
+    Icon(Icons.info),
+  ],
+)
+```
+
+---
+
+## Vertical Viewport Given Unbounded Height
+
+**Error:** `Vertical viewport was given unbounded height.`
+
+**Cause:** A `ListView` (or other scrollable) is placed inside a `Column` without a bounded height.
+
+**Fix:** Wrap the `ListView` in `Expanded` or give it a fixed height with `SizedBox`:
+
+```dart
+Column(
+  children: [
+    Text('Header'),
+    Expanded(
+      child: ListView(children: [...]),
+    ),
+  ],
+)
+```
+
+---
+
+## InputDecorator Cannot Have Unbounded Width
+
+**Error:** `An InputDecorator...cannot have an unbounded width.`
+
+**Cause:** A `TextField` or similar widget is placed in a context without width constraints.
+
+**Fix:** Wrap it in `Expanded`, `SizedBox`, or any parent that provides width constraints:
+
+```dart
+Row(
+  children: [
+    Expanded(child: TextField()),
+  ],
+)
+```
+
+---
+
+## setState Called During Build
+
+**Error:** `setState() or markNeedsBuild() called during build.`
+
+**Cause:** `setState` or `showDialog` is called directly inside the `build` method.
+
+**Fix:** Trigger state changes in response to user actions, or defer to after the frame using `addPostFrameCallback`:
+
+```dart
+@override
+void initState() {
+  super.initState();
+  WidgetsBinding.instance.addPostFrameCallback((_) {
+    // Safe to call setState or showDialog here
+  });
+}
+```
+
+---
+
+## ScrollController Attached to Multiple Scroll Views
+
+**Error:** `The ScrollController is attached to multiple scroll views.`
+
+**Cause:** A single `ScrollController` instance is shared across more than one scrollable widget simultaneously.
+
+**Fix:** Ensure each scrollable widget has its own dedicated `ScrollController` instance.
+
+---
+
+## RenderBox Was Not Laid Out
+
+**Error:** `RenderBox was not laid out: ...`
+
+**Cause:** A widget is missing or has unbounded constraints — commonly `ListView` or `Column` without proper size constraints.
+
+**Fix:** Review your widget tree for missing constraints. Common patterns:
+
+- Wrap `ListView` in `Expanded` inside a `Column`.
+- Give widgets an explicit `width` or `height` via `SizedBox` or `ConstrainedBox`.
+
+---
+
+## Debugging Layout Issues
+
+- Use the **Flutter Inspector** (in DevTools) to visualize widget constraints.
+- Enable **"Show guidelines"** to see layout boundaries.
+- Add `debugPaintSizeEnabled = true;` temporarily in your `main()` to paint layout bounds.
+- Refer to the [Flutter constraints documentation](https://docs.flutter.dev/ui/layout/constraints) for a deeper understanding of how constraints propagate.
+
+## References
+
+- [Flutter Website GitHub Repository](https://github.com/flutter/website)

package/skills/flutter-fix-layout-issues/SKILL.md

@@ -0,0 +1,134 @@
+---
+name: flutter-fix-layout-issues
+description: Fixes Flutter layout errors (overflows, unbounded constraints) using Dart and Flutter MCP tools. Use when addressing "RenderFlex overflowed", "Vertical viewport was given unbounded height", or similar layout issues.
+metadata:
+  model: models/gemini-3.1-pro-preview
+  last_modified: Tue, 21 Apr 2026 19:45:59 GMT
+intents: [debug]
+stacks: [flutter]
+source: https://github.com/flutter/skills
+license: BSD-3-Clause
+---
+# Resolving Flutter Layout Errors
+
+## Contents
+- [Constraint Violation Diagnostics](#constraint-violation-diagnostics)
+- [Layout Error Resolution Workflow](#layout-error-resolution-workflow)
+- [Examples](#examples)
+
+## Constraint Violation Diagnostics
+
+Flutter layout operates on a strict rule: **Constraints go down. Sizes go up. Parent sets position.** Layout errors occur when this negotiation fails, typically due to unbounded constraints or unconstrained children. 
+
+Diagnose layout failures using the following error signatures:
+
+*   **"Vertical viewport was given unbounded height"**: Triggered when a scrollable widget (`ListView`, `GridView`) is placed inside an unconstrained vertical parent (`Column`). The parent provides infinite height, and the child attempts to expand infinitely.
+*   **"An InputDecorator...cannot have an unbounded width"**: Triggered when a `TextField` or `TextFormField` is placed inside an unconstrained horizontal parent (`Row`). The text field attempts to determine its width based on infinite available space.
+*   **"RenderFlex overflowed"**: Triggered when a child of a `Row` or `Column` requests a size larger than the parent's allocated constraints. Visually indicated by yellow and black warning stripes.
+*   **"Incorrect use of ParentData widget"**: Triggered when a `ParentDataWidget` is not a direct descendant of its required ancestor. (e.g., `Expanded` outside a `Flex`, `Positioned` outside a `Stack`).
+*   **"RenderBox was not laid out"**: A cascading side-effect error. Ignore this and look further up the stack trace for the primary constraint violation (usually an unbounded height/width error).
+
+## Layout Error Resolution Workflow
+
+Copy and use this checklist to systematically resolve layout constraint violations.
+
+### Task Progress
+- [ ] Run the application in debug mode to capture the exact layout exception in the console.
+- [ ] Identify the primary error message (ignore cascading "RenderBox was not laid out" errors).
+- [ ] Apply the conditional fix based on the specific error type:
+  - **If "Vertical viewport was given unbounded height"**: Wrap the scrollable child (`ListView`, `GridView`) in an `Expanded` widget to consume remaining space, or wrap it in a `SizedBox` to provide an absolute height constraint.
+  - **If "An InputDecorator...cannot have an unbounded width"**: Wrap the `TextField` or `TextFormField` in an `Expanded` or `Flexible` widget.
+  - **If "RenderFlex overflowed"**: Constrain the overflowing child by wrapping it in an `Expanded` widget (to force it to fit) or a `Flexible` widget (to allow it to be smaller than the allocated space).
+  - **If "Incorrect use of ParentData widget"**: Move the `ParentDataWidget` to be a direct child of its required parent. Ensure `Expanded`/`Flexible` are direct children of `Row`/`Column`/`Flex`. Ensure `Positioned` is a direct child of `Stack`.
+- [ ] Execute Flutter hot reload.
+- [ ] Run validator -> review errors -> fix: Inspect the UI to verify the red/grey error screen or yellow/black overflow stripes are resolved. If new layout errors appear, repeat the workflow.
+
+## Examples
+
+### Fixing Unbounded Height (ListView in Column)
+
+**Input (Error State):**
+```dart
+// Throws "Vertical viewport was given unbounded height"
+Column(
+  children: <Widget>[
+    const Text('Header'),
+    ListView(
+      children: const <Widget>[
+        ListTile(title: Text('Item 1')),
+        ListTile(title: Text('Item 2')),
+      ],
+    ),
+  ],
+)
+```
+
+**Output (Resolved State):**
+```dart
+// Wrap ListView in Expanded to constrain its height to the remaining Column space
+Column(
+  children: <Widget>[
+    const Text('Header'),
+    Expanded(
+      child: ListView(
+        children: const <Widget>[
+          ListTile(title: Text('Item 1')),
+          ListTile(title: Text('Item 2')),
+        ],
+      ),
+    ),
+  ],
+)
+```
+
+### Fixing Unbounded Width (TextField in Row)
+
+**Input (Error State):**
+```dart
+// Throws "An InputDecorator...cannot have an unbounded width"
+Row(
+  children: [
+    const Icon(Icons.search),
+    TextField(), 
+  ],
+)
+```
+
+**Output (Resolved State):**
+```dart
+// Wrap TextField in Expanded to constrain its width to the remaining Row space
+Row(
+  children: [
+    const Icon(Icons.search),
+    Expanded(
+      child: TextField(),
+    ),
+  ],
+)
+```
+
+### Fixing RenderFlex Overflow
+
+**Input (Error State):**
+```dart
+// Throws "A RenderFlex overflowed by X pixels on the right"
+Row(
+  children: [
+    const Icon(Icons.info),
+    const Text('This is a very long text string that will definitely overflow the available screen width and cause a RenderFlex error.'),
+  ],
+)
+```
+
+**Output (Resolved State):**
+```dart
+// Wrap the Text widget in Expanded to force it to wrap within the available constraints
+Row(
+  children: [
+    const Icon(Icons.info),
+    Expanded(
+      child: const Text('This is a very long text string that will definitely overflow the available screen width and cause a RenderFlex error.'),
+    ),
+  ],
+)
+```