A High-Integrity Flutter application built with rigor, reliability, and strict engineering standards derived from the Joint Strike Fighter (JSF) C++ Coding Standards.

This repository serves as the official reference implementation for the Mission-Critical Flutter (MCF) methodology.
It demonstrates how to build safety‑critical mobile applications where failure is not an option.

Standard Flutter encourages rapid prototyping — but speed introduces risk.
Mission‑critical systems demand something else:

• Deterministic behavior
• Architectural isolation
• Total type safety
• Predictable state flow

MCF enforces a strict Dart subset to eliminate entire classes of runtime errors such as:

• TypeError
• NullPointer
• Race conditions
• Illegal layer access
• Uncaught UI states

1. Architecture: Strict separation of Presentation, Domain, and Data Layers.
2. Safety: Zero tolerance for dynamic, implicit casts, or unsafely nullable logic.
3. State: Immutable, exhaustive, unidirectional state machines.
4. Verification: 100% business logic test coverage + Golden tests for UI stability.

This project follows a Clean Architecture pattern with a strict Composition Root, ensuring that dependencies only flow downward.

main.dart is the single entry point that assembles the complete dependency graph.

The Domain layer is completely pure:
❌ No Flutter
❌ No JSON
❌ No HTTP
❌ No UI imports

lib/
├── domain/            # PURE LOGIC (Rules, Entities, Failures, Interfaces)
│   ├── entities/
│   ├── failures/
│   └── repositories/  # Abstract Contracts Only
│
├── data/              # INFRASTRUCTURE (Serialization, Networking)
│   ├── models/        # DTOs -> Entities
│   └── repositories/  # Concrete Implementations
│
├── presentation/      # UI + State (Flutter Only)
│   ├── cubit/         # Logic Containers (Enforce Rule 5.1)
│   └── screens/       # Stateless Widgets
│
└── main.dart          # COMPOSITION ROOT

State must always flow downward.
UI elements never mutate state directly.

• UI dispatches an event/intent
• Cubit processes the event using Domain logic
• Cubit emits a new immutable state
• UI rebuilds based on that state

No shortcuts. No mutable leaks. Zero ambiguity.

To avoid human error and enforce strict compliance, use the official MCF CLI:

Pub.dev: https://pub.dev/packages/mcf_cli
Repository: https://github.com/LosPhilly/mcf_cli

dart pub global activate mcf_cli

mcf create feature user_profile

This creates:

• Domain entity + repository contract
• Data DTO + repository implementation
• Presentation Cubit + State + UI scaffold
• Strict imports + analysis rules

• Flutter SDK 3.10.0+
• Dart SDK 3.0.0+ (sealed classes support)

Clone the repository:

git clone https://github.com/LosPhilly/mission-critical-flutter
cd flightapp

Install dependencies:

flutter pub get

Run:

flutter run

This project uses the Mission-Critical Test Pyramid:

100% branch coverage for Cubits + Domain logic.

flutter test test/presentation/cubit/user_cubit_test.dart

Ensures correct wiring between state and UI.

flutter test test/presentation/screens/profile_screen_test.dart

Ensures pixel-perfect UI rendering over time.

Run:

flutter test test/presentation/screens/profile_screen_golden_test.dart

Regenerate after intentional UI changes:

flutter test --update-goldens

Licensed under the MIT License.
See the LICENSE file for full details.

"The difference between a prototype and a product is not features; it is predictability."

If you reference this architecture or implementation:

Phillips, Carlos. (2025). Mission-Critical Flutter: Building High-Integrity Applications.