runanywhere-flutter/
├── packages/
│   ├── runanywhere/              # Core SDK (required)
│   │   ├── lib/
│   │   │   ├── public/           # Public API surface
│   │   │   ├── core/             # Core types, protocols
│   │   │   ├── features/         # LLM, STT, TTS, VAD implementations
│   │   │   ├── foundation/       # Configuration, DI, errors, logging
│   │   │   ├── infrastructure/   # Device, download, events, files
│   │   │   ├── data/             # Network layer
│   │   │   ├── native/           # FFI bindings to C++
│   │   │   └── capabilities/     # Voice session handling
│   │   ├── ios/                  # iOS plugin + RACommons.xcframework
│   │   └── android/              # Android plugin + JNI libraries
│   │
│   ├── runanywhere_llamacpp/     # LlamaCpp backend (LLM)
│   │   ├── lib/                  # Dart bindings + model registration
│   │   ├── ios/                  # RABackendLLAMACPP.xcframework
│   │   └── android/              # librac_backend_llamacpp.so
│   │
│   └── runanywhere_onnx/         # ONNX backend (STT/TTS/VAD)
│       ├── lib/                  # Dart bindings + model registration
│       ├── ios/                  # RABackendONNX.xcframework + onnxruntime
│       └── android/              # librac_backend_onnx.so + ONNX Runtime
│
├── melos.yaml                    # Multi-package management
├── scripts/                      # Build scripts
└── analysis_options.yaml         # Shared lint rules

┌─────────────────────────────────────────────────────────────────┐
│                      Your Flutter Application                     │
├─────────────────────────────────────────────────────────────────┤
│                    RunAnywhere Flutter SDK                        │
│  ┌─────────────┐  ┌────────────────┐  ┌─────────────────────┐  │
│  │ RunAnywhere │  │   EventBus     │  │   ModelRegistry     │  │
│  │ (Public API)│  │   (Events)     │  │   (Discovery)       │  │
│  └─────────────┘  └────────────────┘  └─────────────────────┘  │
├─────────────────────────────────────────────────────────────────┤
│                    DartBridge (FFI Layer)                         │
│  ┌─────────────┐  ┌────────────────┐  ┌─────────────────────┐  │
│  │DartBridgeLLM│  │ DartBridgeSTT  │  │   DartBridgeTTS     │  │
│  └─────────────┘  └────────────────┘  └─────────────────────┘  │
├─────────────────────────────────────────────────────────────────┤
│                  runanywhere-commons (C++)                        │
│  ┌─────────────┐  ┌────────────────┐  ┌─────────────────────┐  │
│  │ModuleRegistry│ │ServiceRegistry │  │   EventPublisher    │  │
│  └─────────────┘  └────────────────┘  └─────────────────────┘  │
├────────────┬─────────────┬──────────────────────────────────────┤
│  LlamaCPP  │    ONNX     │        (Future Backends...)          │
│  Backend   │   Backend   │                                       │
└────────────┴─────────────┴──────────────────────────────────────┘

public/
├── runanywhere.dart              # Main entry point (RunAnywhere class)
├── configuration/
│   └── sdk_environment.dart      # SDKEnvironment enum
├── errors/
│   └── errors.dart               # SDKError, error codes
├── events/
│   ├── event_bus.dart            # EventBus singleton
│   └── sdk_event.dart            # SDKEvent base class
├── extensions/
│   ├── runanywhere_frameworks.dart   # Framework extensions
│   ├── runanywhere_logging.dart      # Logging extensions
│   └── runanywhere_storage.dart      # Storage extensions
└── types/
    ├── types.dart                # Re-exports all types
    ├── capability_types.dart     # STTCapability, TTSCapability
    ├── configuration_types.dart  # SDKInitParams
    ├── download_types.dart       # DownloadProgress, DownloadProgressState
    ├── generation_types.dart     # LLMGenerationOptions, LLMGenerationResult
    ├── message_types.dart        # ChatMessage types
    └── voice_agent_types.dart    # VoiceSession types

core/
├── models/
│   └── audio_format.dart         # AudioFormat enum
├── module/
│   └── runanywhere_module.dart   # RunAnywhereModule protocol
├── protocols/
│   └── component/
│       ├── component.dart        # Component protocol
│       └── component_configuration.dart
└── types/
    ├── component_state.dart      # ComponentState enum
    ├── model_types.dart          # ModelInfo, ModelCategory, InferenceFramework
    ├── sdk_component.dart        # SDKComponent enum (llm, stt, tts, vad)
    └── storage_types.dart        # StorageInfo, StoredModel

features/
├── llm/
│   └── structured_output/
│       ├── generatable.dart      # Generatable mixin
│       ├── generation_hints.dart # GenerationHints
│       ├── stream_accumulator.dart
│       ├── stream_token.dart
│       ├── structured_output.dart
│       └── structured_output_handler.dart
├── stt/
│   └── services/
│       └── audio_capture_manager.dart
├── tts/
│   ├── services/
│   │   └── audio_playback_manager.dart
│   └── system_tts_service.dart   # Fallback to flutter_tts
└── vad/
    ├── simple_energy_vad.dart    # Energy-based VAD
    └── vad_configuration.dart    # VADConfiguration

native/
├── dart_bridge.dart              # Main bridge coordinator
├── dart_bridge_device.dart       # Device info bridge
├── dart_bridge_llm.dart          # LLM operations bridge
├── dart_bridge_model_paths.dart  # Model path resolution
├── dart_bridge_model_registry.dart # Model registry bridge
├── dart_bridge_stt.dart          # STT operations bridge
├── dart_bridge_tts.dart          # TTS operations bridge
├── dart_bridge_voice_agent.dart  # Voice agent bridge
├── native_backend.dart           # NativeBackend class
├── platform_loader.dart          # Platform-specific loading
├── ffi_types.dart                # FFI type definitions
└── ... (additional bridge files)

class RunAnywhere {
  // Initialization
  static Future<void> initialize({...}) async { ... }

  // LLM Operations
  static Future<String> chat(String prompt) async { ... }
  static Future<LLMGenerationResult> generate(String prompt, {...}) async { ... }
  static Future<LLMStreamingResult> generateStream(String prompt, {...}) async { ... }

  // STT Operations
  static Future<String> transcribe(Uint8List audioData) async { ... }

  // TTS Operations
  static Future<TTSResult> synthesize(String text, {...}) async { ... }

  // Voice Agent
  static Future<VoiceSessionHandle> startVoiceSession({...}) async { ... }

  // Model Management
  static Future<List<ModelInfo>> availableModels() async { ... }
  static Stream<DownloadProgress> downloadModel(String modelId) async* { ... }
  static Future<void> loadModel(String modelId) async { ... }
}

class DartBridgeLLM {
  String? _currentModelId;
  bool get isLoaded => _currentModelId != null;

  Future<void> loadModel(String path, String modelId, String name) async {
    final result = _bindings.rac_llm_component_load_model(path, modelId, name);
    if (result != RacResultCode.success) {
      throw NativeBackendException('Failed to load model');
    }
    _currentModelId = modelId;
  }

  Stream<String> generateStream(String prompt, {...}) async* {
    // Yields tokens as they're generated
  }
}

abstract class RunAnywhereModule {
  String get moduleId;
  String get moduleName;
  Set<SDKComponent> get capabilities;
  int get defaultPriority;
  InferenceFramework get inferenceFramework;
}

class EventBus {
  static final EventBus shared = EventBus._();
  final StreamController<SDKEvent> _controller =
      StreamController<SDKEvent>.broadcast();

  Stream<SDKEvent> get events => _controller.stream;

  void publish(SDKEvent event) {
    _controller.add(event);
  }
}

1. RunAnywhere.chat(prompt)
   ├─ Validates SDK is initialized
   ├─ Checks DartBridge.llm.isLoaded
   └─ Calls DartBridge.llm.generate(prompt, options)

2. DartBridge.llm.generate()
   ├─ Calls FFI: rac_llm_component_generate(prompt, maxTokens, temp)
   ├─ C++ processes request via registered LlamaCPP backend
   ├─ Returns LLMGenerationResult with text and metrics
   └─ Publishes SDKModelEvent.generationCompleted

3. Events Published:
   └─ SDKModelEvent (captured by EventBus subscribers)

1. RunAnywhere.generateStream(prompt, options)
   ├─ Creates StreamController<String>.broadcast()
   ├─ Calls DartBridge.llm.generateStream(prompt, options)
   └─ Returns LLMStreamingResult(stream, result future, cancel fn)

2. DartBridge.llm.generateStream()
   ├─ Calls FFI: rac_llm_component_generate_stream_start()
   ├─ Polls for tokens in isolate/async loop
   ├─ Yields tokens to StreamController
   └─ Completes when generation ends or cancelled

3. App consumes:
   await for (final token in result.stream) {
     updateUI(token);  // Real-time token display
   }
   final metrics = await result.result;  // Final stats

1. RunAnywhere.loadModel(modelId)
   ├─ Validates SDK initialized
   ├─ Gets model from availableModels()
   ├─ Verifies model.localPath is set (downloaded)
   ├─ Resolves actual file path via DartBridge.modelPaths
   └─ Calls DartBridge.llm.loadModel(resolvedPath, modelId, name)

2. DartBridge.llm.loadModel()
   ├─ Unloads current model if any
   ├─ Calls FFI: rac_llm_component_load_model(path, id, name)
   ├─ C++ LlamaCPP backend loads GGUF model
   └─ Updates _currentModelId on success

3. Events Published:
   ├─ SDKModelEvent.loadStarted(modelId)
   └─ SDKModelEvent.loadCompleted(modelId) or loadFailed

1. VoiceSessionHandle receives audio
   ├─ Validates voice agent is ready (STT + LLM + TTS loaded)
   └─ Calls DartBridge.voiceAgent.processVoiceTurn(audioData)

2. DartBridge.voiceAgent.processVoiceTurn()
   ├─ Step 1: STT - rac_stt_component_transcribe(audioData) → text
   ├─ Step 2: LLM - rac_llm_component_generate(text) → response
   ├─ Step 3: TTS - rac_tts_component_synthesize(response) → audio
   └─ Returns VoiceAgentProcessResult

3. Session emits events:
   ├─ VoiceSessionTranscribed(text)
   ├─ VoiceSessionResponded(response)
   └─ VoiceSessionTurnCompleted(transcript, response, audio)

class MyBackend implements RunAnywhereModule {
  static final MyBackend _instance = MyBackend._internal();

  @override
  String get moduleId => 'my-backend';

  @override
  Set<SDKComponent> get capabilities => {SDKComponent.llm};

  static Future<void> register() async {
    final bindings = MyBackendBindings();
    bindings.rac_backend_mybackend_register();
    _isRegistered = true;
  }

  static void addModel({required String name, required String url}) {
    RunAnywhere.registerModel(
      name: name,
      url: Uri.parse(url),
      framework: InferenceFramework.myBackend,
    );
  }
}

class MyCustomDownloadStrategy implements DownloadStrategy {
  @override
  bool canHandle(Uri url) => url.host == 'my-custom-host.com';

  @override
  Stream<DownloadProgress> download(String modelId, Uri url, String destPath) async* {
    // Custom download implementation
  }
}

RunAnywhere.events.events.listen((event) {
  if (event is SDKModelEvent) {
    analytics.track('model_event', {'type': event.type});
  }
});

melos bootstrap     # Install all package dependencies
melos analyze       # Run flutter analyze on all packages
melos format        # Run dart format on all packages
melos test          # Run tests on all packages
melos clean         # Clean all packages