reis-mobile 0.3.5

package/skills/flutter-handling-concurrency/SKILL.md

@@ -0,0 +1,182 @@
+---
+name: flutter-handling-concurrency
+description: Executes long-running tasks in background isolates to keep the UI responsive. Use when performing heavy computations or parsing large datasets.
+metadata:
+  model: models/gemini-3.1-pro-preview
+  last_modified: Thu, 12 Mar 2026 22:23:14 GMT
+intents: [performance]
+stacks: [flutter]
+source: https://github.com/flutter/skills
+license: BSD-3-Clause
+---
+# Managing Dart Concurrency and Isolates
+
+## Contents
+- [Core Concepts](#core-concepts)
+- [Decision Matrix: Async vs. Isolates](#decision-matrix-async-vs-isolates)
+- [Workflows](#workflows)
+  - [Implementing Standard Asynchronous UI](#implementing-standard-asynchronous-ui)
+  - [Offloading Short-Lived Heavy Computation](#offloading-short-lived-heavy-computation)
+  - [Establishing Long-Lived Worker Isolates](#establishing-long-lived-worker-isolates)
+- [Examples](#examples)
+
+## Core Concepts
+
+Dart utilizes a single-threaded execution model driven by an Event Loop (comparable to the iOS main loop). By default, all Flutter application code runs on the Main Isolate. 
+
+*   **Asynchronous Operations (`async`/`await`):** Use for non-blocking I/O tasks (network requests, file access). The Event Loop continues processing other events while waiting for the `Future` to complete.
+*   **Isolates:** Dart's implementation of lightweight threads. Isolates possess their own isolated memory and do not share state. They communicate exclusively via message passing.
+*   **Main Isolate:** The default thread where UI rendering and event handling occur. Blocking this isolate causes UI freezing (jank).
+*   **Worker Isolate:** A spawned isolate used to offload CPU-bound tasks (e.g., decoding large JSON blobs) to prevent Main Isolate blockage.
+
+## Decision Matrix: Async vs. Isolates
+
+Apply the following conditional logic to determine the correct concurrency approach:
+
+*   **If** the task is I/O bound (e.g., HTTP request, database read) -> **Use `async`/`await`** on the Main Isolate.
+*   **If** the task is CPU-bound but executes quickly (< 16ms) -> **Use `async`/`await`** on the Main Isolate.
+*   **If** the task is CPU-bound, takes significant time, and runs once (e.g., parsing a massive JSON payload) -> **Use `Isolate.run()`**.
+*   **If** the task requires continuous or repeated background processing with multiple messages passed over time -> **Use `Isolate.spawn()` with `ReceivePort` and `SendPort`**.
+
+## Workflows
+
+### Implementing Standard Asynchronous UI
+
+Use this workflow to fetch and display non-blocking asynchronous data.
+
+**Task Progress:**
+- [ ] Mark the data-fetching function with the `async` keyword.
+- [ ] Return a `Future<T>` from the function.
+- [ ] Use the `await` keyword to yield execution until the operation completes.
+- [ ] Wrap the UI component in a `FutureBuilder<T>` (or `StreamBuilder` for streams).
+- [ ] Handle `ConnectionState.waiting`, `hasError`, and `hasData` states within the builder.
+- [ ] Run validator -> review UI for loading indicators -> fix missing states.
+
+### Offloading Short-Lived Heavy Computation
+
+Use this workflow for one-off, CPU-intensive tasks using Dart 2.19+.
+
+**Task Progress:**
+- [ ] Identify the CPU-bound operation blocking the Main Isolate.
+- [ ] Extract the computation into a standalone callback function.
+- [ ] Ensure the callback function signature accepts exactly one required, unnamed argument (as per specific architectural constraints).
+- [ ] Invoke `Isolate.run()` passing the callback.
+- [ ] `await` the result of `Isolate.run()` in the Main Isolate.
+- [ ] Assign the returned value to the application state.
+
+### Establishing Long-Lived Worker Isolates
+
+Use this workflow for persistent background processes requiring continuous bidirectional communication.
+
+**Task Progress:**
+- [ ] Instantiate a `ReceivePort` on the Main Isolate to listen for messages.
+- [ ] Spawn the worker isolate using `Isolate.spawn()`, passing the `ReceivePort.sendPort` as the initial message.
+- [ ] In the worker isolate, instantiate its own `ReceivePort`.
+- [ ] Send the worker's `SendPort` back to the Main Isolate via the initial port.
+- [ ] Store the worker's `SendPort` in the Main Isolate for future message dispatching.
+- [ ] Implement listeners on both `ReceivePort` instances to handle incoming messages.
+- [ ] Run validator -> review memory leaks -> ensure ports are closed when the isolate is no longer needed.
+
+## Examples
+
+### Example 1: Asynchronous UI with FutureBuilder
+
+```dart
+// 1. Define the async operation
+Future<String> fetchUserData() async {
+  await Future.delayed(const Duration(seconds: 2)); // Simulate network I/O
+  return "User Data Loaded";
+}
+
+// 2. Consume in the UI
+Widget build(BuildContext context) {
+  return FutureBuilder<String>(
+    future: fetchUserData(),
+    builder: (context, snapshot) {
+      if (snapshot.connectionState == ConnectionState.waiting) {
+        return const CircularProgressIndicator();
+      } else if (snapshot.hasError) {
+        return Text('Error: ${snapshot.error}');
+      } else {
+        return Text('Result: ${snapshot.data}');
+      }
+    },
+  );
+}
+```
+
+### Example 2: Short-Lived Isolate (`Isolate.run`)
+
+```dart
+import 'dart:isolate';
+import 'dart:convert';
+
+// 1. Define the heavy computation callback
+// Note: Adhering to the strict single-argument signature requirement.
+List<dynamic> decodeHeavyJson(String jsonString) {
+  return jsonDecode(jsonString) as List<dynamic>;
+}
+
+// 2. Offload to a worker isolate
+Future<List<dynamic>> processDataInBackground(String rawJson) async {
+  // Isolate.run spawns the isolate, runs the computation, returns the value, and exits.
+  final result = await Isolate.run(() => decodeHeavyJson(rawJson));
+  return result;
+}
+```
+
+### Example 3: Long-Lived Isolate (`ReceivePort` / `SendPort`)
+
+```dart
+import 'dart:isolate';
+
+class WorkerManager {
+  late SendPort _workerSendPort;
+  final ReceivePort _mainReceivePort = ReceivePort();
+  Isolate? _isolate;
+
+  Future<void> initialize() async {
+    // 1. Spawn isolate and pass the Main Isolate's SendPort
+    _isolate = await Isolate.spawn(_workerEntry, _mainReceivePort.sendPort);
+
+    // 2. Listen for messages from the Worker Isolate
+    _mainReceivePort.listen((message) {
+      if (message is SendPort) {
+        // First message is the Worker's SendPort
+        _workerSendPort = message;
+        _startCommunication();
+      } else {
+        // Subsequent messages are data payloads
+        print('Main Isolate received: $message');
+      }
+    });
+  }
+
+  void _startCommunication() {
+    // Send data to the worker
+    _workerSendPort.send("Process this data");
+  }
+
+  // 3. Worker Isolate Entry Point
+  static void _workerEntry(SendPort mainSendPort) {
+    final workerReceivePort = ReceivePort();
+    
+    // Send the Worker's SendPort back to the Main Isolate
+    mainSendPort.send(workerReceivePort.sendPort);
+
+    // Listen for incoming tasks
+    workerReceivePort.listen((message) {
+      print('Worker Isolate received: $message');
+      
+      // Perform work and send result back
+      final result = "Processed: $message";
+      mainSendPort.send(result);
+    });
+  }
+
+  void dispose() {
+    _mainReceivePort.close();
+    _isolate?.kill();
+  }
+}
+```

package/skills/flutter-implement-json-serialization/SKILL.md

@@ -0,0 +1,157 @@
+---
+name: flutter-implement-json-serialization
+description: Create model classes with `fromJson` and `toJson` methods using `dart:convert`. Use when manually mapping JSON keys to class properties for simple data structures.
+metadata:
+  model: models/gemini-3.1-pro-preview
+  last_modified: Tue, 21 Apr 2026 21:44:50 GMT
+routing: manual
+stacks: [flutter]
+source: https://github.com/flutter/skills
+license: BSD-3-Clause
+---
+# Serializing JSON Manually in Flutter
+
+## Contents
+- [Core Guidelines](#core-guidelines)
+- [Workflow: Implementing a Serializable Model](#workflow-implementing-a-serializable-model)
+- [Workflow: Fetching and Parsing JSON](#workflow-fetching-and-parsing-json)
+- [Examples](#examples)
+
+## Core Guidelines
+
+- **Import `dart:convert`**: Utilize Flutter's built-in `dart:convert` library for manual JSON encoding (`jsonEncode`) and decoding (`jsonDecode`).
+- **Enforce Type Safety**: Always cast the `dynamic` result of `jsonDecode()` to the expected type, typically `Map<String, dynamic>` for objects or `List<dynamic>` for arrays.
+- **Encapsulate Serialization Logic**: Define plain model classes containing properties corresponding to the JSON structure. Implement a `fromJson` factory constructor and a `toJson` method within the model.
+- **Handle Background Parsing**: If parsing large JSON documents (execution time > 16ms), offload the parsing logic to a separate isolate using Flutter's `compute()` function to prevent UI jank.
+- **Throw Exceptions on Failure**: When handling HTTP responses, throw an exception if the status code is not successful (e.g., not 200 OK or 201 Created). Do not return `null`.
+
+## Workflow: Implementing a Serializable Model
+
+Use this checklist to implement manual JSON serialization for a data model.
+
+**Task Progress:**
+- [ ] Define the plain model class with `final` properties.
+- [ ] Implement the `factory Model.fromJson(Map<String, dynamic> json)` constructor.
+- [ ] Implement the `Map<String, dynamic> toJson()` method.
+- [ ] Write unit tests for both serialization methods.
+- [ ] Run validator -> review type mismatch errors -> fix casting logic.
+
+1. **Define the Model**: Create a class with properties matching the JSON keys.
+2. **Implement `fromJson`**: Extract values from the `Map` and cast them to the appropriate Dart types. Use pattern matching or explicit casting.
+3. **Implement `toJson`**: Return a `Map<String, dynamic>` mapping the class properties back to their JSON string keys.
+4. **Validate**: Execute unit tests to ensure type safety, autocompletion, and compile-time exception handling function correctly.
+
+## Workflow: Fetching and Parsing JSON
+
+Use this conditional workflow when retrieving and parsing JSON from a network request.
+
+**Task Progress:**
+- [ ] Execute the HTTP request.
+- [ ] Validate the response status code.
+- [ ] Determine parsing strategy (Synchronous vs. Isolate).
+- [ ] Decode and map the JSON to the model.
+
+1. **Execute Request**: Use the `http` package to perform the network call.
+2. **Validate Response**: 
+   - If `response.statusCode == 200` (or 201 for POST), proceed to parsing.
+   - If the status code indicates failure, throw an `Exception`.
+3. **Determine Parsing Strategy**:
+   - If parsing a **small payload** (e.g., a single object), parse synchronously on the main thread.
+   - If parsing a **large payload** (e.g., an array of thousands of objects), use `compute(parseFunction, response.body)` to parse in a background isolate.
+4. **Decode and Map**: Pass the decoded JSON to your model's `fromJson` constructor.
+
+## Examples
+
+### High-Fidelity Model Implementation
+
+```dart
+import 'dart:convert';
+
+class User {
+  final int id;
+  final String name;
+  final String email;
+
+  const User({
+    required this.id,
+    required this.name,
+    required this.email,
+  });
+
+  // Factory constructor for deserialization
+  factory User.fromJson(Map<String, dynamic> json) {
+    return switch (json) {
+      {
+        'id': int id,
+        'name': String name,
+        'email': String email,
+      } => 
+        User(
+          id: id,
+          name: name,
+          email: email,
+        ),
+      _ => throw const FormatException('Failed to load User.'),
+    };
+  }
+
+  // Method for serialization
+  Map<String, dynamic> toJson() {
+    return {
+      'id': id,
+      'name': name,
+      'email': email,
+    };
+  }
+}
+```
+
+### Synchronous Parsing (Small Payload)
+
+```dart
+import 'dart:convert';
+import 'package:http/http.dart' as http;
+
+Future<User> fetchUser(http.Client client, int userId) async {
+  final response = await client.get(
+    Uri.parse('https://api.example.com/users/$userId'),
+    headers: {'Accept': 'application/json'},
+  );
+
+  if (response.statusCode == 200) {
+    // Decode returns dynamic, cast to Map<String, dynamic>
+    final Map<String, dynamic> jsonMap = jsonDecode(response.body) as Map<String, dynamic>;
+    return User.fromJson(jsonMap);
+  } else {
+    throw Exception('Failed to load user');
+  }
+}
+```
+
+### Background Parsing (Large Payload)
+
+```dart
+import 'dart:convert';
+import 'package:flutter/foundation.dart';
+import 'package:http/http.dart' as http;
+
+// Top-level function required for compute()
+List<User> parseUsers(String responseBody) {
+  final parsed = (jsonDecode(responseBody) as List<dynamic>).cast<Map<String, dynamic>>();
+  return parsed.map<User>((json) => User.fromJson(json)).toList();
+}
+
+Future<List<User>> fetchUsers(http.Client client) async {
+  final response = await client.get(
+    Uri.parse('https://api.example.com/users'),
+    headers: {'Accept': 'application/json'},
+  );
+
+  if (response.statusCode == 200) {
+    // Offload expensive parsing to a background isolate
+    return compute(parseUsers, response.body);
+  } else {
+    throw Exception('Failed to load users');
+  }
+}
+```

package/skills/flutter-improving-accessibility/SKILL.md

@@ -0,0 +1,113 @@
+---
+name: flutter-improving-accessibility
+description: Configures a Flutter app to support assistive technologies like Screen Readers. Use when ensuring an application is usable for people with disabilities.
+metadata:
+  model: models/gemini-3.1-pro-preview
+  last_modified: Thu, 12 Mar 2026 22:17:37 GMT
+intents: [accessibility]
+stacks: [flutter]
+source: https://github.com/flutter/skills
+license: BSD-3-Clause
+---
+# Implementing Flutter Accessibility
+
+## Contents
+- [UI Design and Styling](#ui-design-and-styling)
+- [Accessibility Widgets](#accessibility-widgets)
+- [Web Accessibility](#web-accessibility)
+- [Adaptive and Responsive Design](#adaptive-and-responsive-design)
+- [Workflows](#workflows)
+- [Examples](#examples)
+
+## UI Design and Styling
+Design layouts to accommodate dynamic scaling and high visibility. Flutter automatically calculates font sizes based on OS-level accessibility settings.
+
+*   **Font Scaling:** Ensure layouts provide sufficient room to render all contents when font sizes are increased to their maximum OS settings. Avoid hardcoding fixed heights on text containers.
+*   **Color Contrast:** Maintain a contrast ratio of at least 4.5:1 for small text and 3.0:1 for large text (18pt+ regular or 14pt+ bold) to meet W3C standards.
+*   **Tap Targets:** Enforce a minimum tap target size of 48x48 logical pixels to accommodate users with limited dexterity.
+
+## Accessibility Widgets
+Utilize Flutter's catalog of accessibility widgets to manipulate the semantics tree exposed to assistive technologies (like TalkBack or VoiceOver).
+
+*   **`Semantics`**: Use this to annotate the widget tree with a description of the meaning of the widgets. Assign specific roles using the `SemanticsRole` enum (e.g., button, link, heading) when building custom components.
+*   **`MergeSemantics`**: Wrap composite widgets to merge the semantics of all descendants into a single selectable node for screen readers.
+*   **`ExcludeSemantics`**: Use this to drop the semantics of all descendants, hiding redundant or purely decorative sub-widgets from accessibility tools.
+
+## Web Accessibility
+Flutter web renders UI on a single canvas, requiring a specialized DOM layer to expose structure to browsers.
+
+*   **Enable Semantics:** Web accessibility is disabled by default for performance. Users can enable it via an invisible button (`aria-label="Enable accessibility"`). 
+*   **Programmatic Enablement:** If building a web-first application requiring default accessibility, force the semantics tree generation at startup.
+*   **Semantic Roles:** Rely on standard widgets (`TabBar`, `MenuAnchor`, `Table`) for automatic ARIA role mapping. For custom components, explicitly assign `SemanticsRole` values to ensure screen readers interpret the elements correctly.
+
+## Adaptive and Responsive Design
+Differentiate between adaptive and responsive paradigms to build universal applications.
+
+*   **Responsive Design:** Adjust the placement, sizing, and reflowing of design elements to fit the available screen space.
+*   **Adaptive Design:** Select appropriate layouts (e.g., bottom navigation vs. side panel) and input mechanisms (e.g., touch vs. mouse/keyboard) to make the UI usable within the current device context. Design to the strengths of each form factor.
+
+## Workflows
+
+### Task Progress: Accessibility Implementation
+Copy this checklist to track accessibility compliance during UI development:
+
+- [ ] Verify all interactive elements have a minimum tap target of 48x48 pixels.
+- [ ] Test layout with maximum OS font size settings to ensure no text clipping or overflow occurs.
+- [ ] Validate color contrast ratios (4.5:1 for normal text, 3.0:1 for large text).
+- [ ] Wrap custom interactive widgets in `Semantics` and assign the appropriate `SemanticsRole`.
+- [ ] Group complex composite widgets using `MergeSemantics` to prevent screen reader fatigue.
+- [ ] Hide decorative elements from screen readers using `ExcludeSemantics`.
+- [ ] If targeting web, verify ARIA roles are correctly mapped and consider programmatic enablement of the semantics tree.
+
+### Feedback Loop: Accessibility Validation
+Run this loop when finalizing a view or component:
+1. **Run validator:** Execute accessibility tests or use OS-level screen readers (VoiceOver/TalkBack) to navigate the view.
+2. **Review errors:** Identify unannounced interactive elements, trapped focus, or clipped text.
+3. **Fix:** Apply `Semantics`, adjust constraints, or modify colors. Repeat until the screen reader provides a clear, logical traversal of the UI.
+
+## Examples
+
+### Programmatic Web Accessibility Enablement
+If targeting web and requiring accessibility by default, initialize the semantics binding before running the app.
+
+```dart
+import 'package:flutter/material.dart';
+import 'package:flutter/semantics.dart';
+import 'package:flutter/foundation.dart';
+
+void main() {
+  if (kIsWeb) {
+    SemanticsBinding.instance.ensureSemantics();
+  }
+  runApp(const MyApp());
+}
+```
+
+### Custom Component Semantics
+If building a custom widget that acts as a list item, explicitly define its semantic role so assistive technologies and web ARIA mappings interpret it correctly.
+
+```dart
+import 'package:flutter/material.dart';
+import 'package:flutter/semantics.dart';
+
+class CustomListItem extends StatelessWidget {
+  final String text;
+
+  const CustomListItem({super.key, required this.text});
+
+  @override
+  Widget build(BuildContext context) {
+    return Semantics(
+      role: SemanticsRole.listItem,
+      label: text,
+      child: Padding(
+        padding: const EdgeInsets.all(12.0), // Ensures > 48px tap target if interactive
+        child: Text(
+          text,
+          style: const TextStyle(fontSize: 16), // Ensure contrast ratio > 4.5:1
+        ),
+      ),
+    );
+  }
+}
+```

package/skills/flutter-interoperating-with-native-apis/SKILL.md

@@ -0,0 +1,130 @@
+---
+name: flutter-interoperating-with-native-apis
+description: Interoperates with native platform APIs on Android, iOS, and the web. Use when accessing device-specific features not available in Dart or calling existing native code.
+metadata:
+  model: models/gemini-3.1-pro-preview
+  last_modified: Thu, 12 Mar 2026 22:21:02 GMT
+routing: manual
+stacks: [flutter]
+source: https://github.com/flutter/skills
+license: BSD-3-Clause
+---
+# Integrating Platform-Specific Code in Flutter
+
+## Contents
+- [Core Concepts & Terminology](#core-concepts--terminology)
+- [Binding to Native C/C++ Code (FFI)](#binding-to-native-cc-code-ffi)
+- [Implementing Platform Channels & Pigeon](#implementing-platform-channels--pigeon)
+- [Hosting Native Platform Views](#hosting-native-platform-views)
+- [Integrating Web Content & Wasm](#integrating-web-content--wasm)
+- [Workflows](#workflows)
+
+## Core Concepts & Terminology
+- **FFI (Foreign Function Interface):** The `dart:ffi` library used to bind Dart directly to native C/C++ APIs.
+- **Platform Channel:** The asynchronous message-passing system (`MethodChannel`, `BasicMessageChannel`) connecting the Dart client (UI) to the host platform (Kotlin/Java, Swift/Objective-C, C++).
+- **Pigeon:** A code-generation tool that creates type-safe Platform Channels.
+- **Platform View:** A mechanism to embed native UI components (e.g., Android `View`, iOS `UIView`) directly into the Flutter widget tree.
+- **JS Interop:** The modern, Wasm-compatible approach to interacting with JavaScript and DOM APIs using `package:web` and `dart:js_interop`.
+
+## Binding to Native C/C++ Code (FFI)
+Use FFI to execute high-performance native code or utilize existing C/C++ libraries without the overhead of asynchronous Platform Channels.
+
+### Project Setup
+*   **If creating a standard C/C++ integration (Recommended since Flutter 3.38):** Use the `package_ffi` template. This utilizes `build.dart` hooks to compile native code, eliminating the need for OS-specific build files (CMake, build.gradle, podspec).
+    ```bash
+    flutter create --template=package_ffi <package_name>
+    ```
+*   **If requiring access to the Flutter Plugin API or Play Services:** Use the legacy `plugin_ffi` template.
+    ```bash
+    flutter create --template=plugin_ffi <plugin_name>
+    ```
+
+### Implementation Rules
+*   **Symbol Visibility:** Always mark C++ symbols with `extern "C"` and prevent linker discarding during link-time optimization (LTO).
+    ```cpp
+    extern "C" __attribute__((visibility("default"))) __attribute__((used))
+    ```
+*   **Dynamic Library Naming (Apple Platforms):** Ensure your `build.dart` hook produces the exact same filename across all target architectures (e.g., `arm64` vs `x86_64`) and SDKs (`iphoneos` vs `iphonesimulator`). Do not append architecture suffixes to the `.dylib` or `.framework` names.
+*   **Binding Generation:** Always use `package:ffigen` to generate Dart bindings from your C headers (`.h`). Configure this in `ffigen.yaml`.
+
+## Implementing Platform Channels & Pigeon
+Use Platform Channels when you need to interact with platform-specific APIs (e.g., Battery, Bluetooth, OS-level services) using the platform's native language.
+
+### Pigeon (Type-Safe Channels)
+Always prefer `package:pigeon` over raw `MethodChannel` implementations for complex or frequently used APIs.
+1.  Define the messaging protocol in a standalone Dart file using Pigeon annotations (`@HostApi()`).
+2.  Generate the host (Kotlin/Swift/C++) and client (Dart) code.
+3.  Implement the generated interfaces on the native side.
+
+### Threading Rules
+*   **Main Thread Requirement:** Always invoke channel methods destined for Flutter on the platform's main thread (UI thread).
+*   **Background Execution:** If executing channel handlers on a background thread (Android/iOS), you must use the Task Queue API (`makeBackgroundTaskQueue()`).
+*   **Isolates:** To use plugins/channels from a Dart background `Isolate`, ensure it is registered using `BackgroundIsolateBinaryMessenger.ensureInitialized(rootIsolateToken)`.
+
+## Hosting Native Platform Views
+Use Platform Views to embed native UI components (e.g., Google Maps, native video players) into the Flutter widget tree.
+
+### Android Platform Views
+Evaluate the trade-offs between the two rendering modes and select the appropriate one:
+*   **If requiring perfect fidelity, accessibility, or SurfaceView support:** Use **Hybrid Composition** (`PlatformViewLink` + `AndroidViewSurface`). This appends the native view to the hierarchy but may reduce Flutter's rendering performance.
+*   **If prioritizing Flutter rendering performance and transformations:** Use **Texture Layer** (`AndroidView`). This renders the native view into a texture. Note: Quick scrolling may drop frames, and `SurfaceView` is problematic.
+
+### iOS Platform Views
+*   iOS exclusively uses Hybrid Composition.
+*   Implement `FlutterPlatformViewFactory` and `FlutterPlatformView` in Swift or Objective-C.
+*   Use the `UiKitView` widget on the Dart side.
+*   *Limitation:* `ShaderMask` and `ColorFiltered` widgets cannot be applied to iOS Platform Views.
+
+## Integrating Web Content & Wasm
+Flutter Web supports compiling to WebAssembly (Wasm) for improved performance and multi-threading.
+
+### Wasm Compilation
+*   Compile to Wasm using: `flutter build web --wasm`.
+*   **Server Configuration:** To enable multi-threading, configure your HTTP server to emit the following headers:
+    *   `Cross-Origin-Embedder-Policy: credentialless` (or `require-corp`)
+    *   `Cross-Origin-Opener-Policy: same-origin`
+*   *Limitation:* WasmGC is not currently supported on iOS browsers (WebKit limitation). Flutter will automatically fall back to JavaScript if WasmGC is unavailable.
+
+### Web Interop
+*   **If writing new web-specific code:** Strictly use `package:web` and `dart:js_interop`.
+*   **Do NOT use:** `dart:html`, `dart:js`, or `package:js`. These are incompatible with Wasm compilation.
+*   **Embedding HTML:** Use `HtmlElementView.fromTagName` to inject arbitrary HTML elements (like `<video>`) into the Flutter Web DOM.
+
+---
+
+## Workflows
+
+### Workflow: Creating a Native FFI Integration
+Use this workflow when binding to a C/C++ library.
+
+- [ ] **Task Progress:**
+  - [ ] 1. Run `flutter create --template=package_ffi <name>`.
+  - [ ] 2. Place C/C++ source code in the `src/` directory.
+  - [ ] 3. Ensure all exported C++ functions are wrapped in `extern "C"` and visibility attributes.
+  - [ ] 4. Configure `ffigen.yaml` to point to your header files.
+  - [ ] 5. Run `dart run ffigen` to generate Dart bindings.
+  - [ ] 6. Modify `hook/build.dart` if linking against pre-compiled or system libraries.
+  - [ ] 7. Run validator -> `flutter test` -> review errors -> fix.
+
+### Workflow: Implementing a Type-Safe Platform Channel (Pigeon)
+Use this workflow when you need to call Kotlin/Swift APIs from Dart.
+
+- [ ] **Task Progress:**
+  - [ ] 1. Add `pigeon` to `dev_dependencies`.
+  - [ ] 2. Create `pigeons/messages.dart` and define data classes and `@HostApi()` abstract classes.
+  - [ ] 3. Run the Pigeon generator script to output Dart, Kotlin, and Swift files.
+  - [ ] 4. **Android:** Implement the generated interface in `MainActivity.kt` or your Plugin class.
+  - [ ] 5. **iOS:** Implement the generated protocol in `AppDelegate.swift` or your Plugin class.
+  - [ ] 6. **Dart:** Import the generated Dart file and call the API methods.
+  - [ ] 7. Run validator -> verify cross-platform compilation -> review errors -> fix.
+
+### Workflow: Embedding a Native Platform View
+Use this workflow when embedding a native UI component (e.g., a native map or camera view).
+
+- [ ] **Task Progress:**
+  - [ ] 1. **Dart:** Create a widget that conditionally returns `AndroidView` (or `PlatformViewLink`) for Android, and `UiKitView` for iOS based on `defaultTargetPlatform`.
+  - [ ] 2. **Android:** Create a class implementing `PlatformView` that returns the native Android `View`.
+  - [ ] 3. **Android:** Create a `PlatformViewFactory` and register it in `configureFlutterEngine`.
+  - [ ] 4. **iOS:** Create a class implementing `FlutterPlatformView` that returns the native `UIView`.
+  - [ ] 5. **iOS:** Create a `FlutterPlatformViewFactory` and register it in `application:didFinishLaunchingWithOptions:`.
+  - [ ] 6. Run validator -> test on physical Android and iOS devices -> review UI clipping/scrolling issues -> fix.

package/skills/flutter-login-usecase/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: flutter-login-usecase
+description: "Implements a Flutter login use case that authenticates through an injected repository and persists the access token through an injected storage abstraction. Use when building or reviewing the login flow of a Flutter app with layered architecture."
+routing: manual
+stacks: [flutter]
+---
+
+# flutter-login-usecase
+
+## Description
+Execute mobile login and persist the access token through injected abstractions.
+
+## Language
+Dart
+
+## Inputs
+- `email: String`
+- `password: String`
+- `repo: AuthRepository`
+- `storage: TokenStorage`
+
+## Returns
+- `Future<void>`
+
+## Example
+```dart
+class LoginUseCase {
+  LoginUseCase(this._repo, this._storage);
+
+  final AuthRepository _repo;
+  final TokenStorage _storage;
+
+  Future<void> call(String email, String password) async {
+    final token = await _repo.login(email, password);
+    await _storage.save(token);
+  }
+}
+```