change names

crates/prometeu-core/src/firmware/firmware.rs

@@ -1,11 +1,13 @@
 use crate::firmware::firmware_state::{FirmwareState, InitAppStep, ResetStep};
-use crate::firmware::FirmwareRequest;
+use crate::firmware::prometeu_context::PrometeuContext;
 use crate::hardware::{HardwareBridge, InputSignals};
 use crate::model::Cartridge;
 use crate::prometeu_hub::PrometeuHub;
 use crate::prometeu_os::PrometeuOS;
+use crate::virtual_machine::VirtualMachine;
 
 pub struct Firmware {
+    pub vm: VirtualMachine,
     pub os: PrometeuOS,
     pub hub: PrometeuHub,
     pub state: FirmwareState,
@@ -15,6 +17,7 @@ pub struct Firmware {
 impl Firmware {
     pub fn new() -> Self {
         Self {
+            vm: VirtualMachine::default(),
             os: PrometeuOS::new(),
             hub: PrometeuHub::new(),
             state: FirmwareState::Reset(ResetStep),
@@ -44,7 +47,8 @@ impl Firmware {
     }
 
     fn on_enter(&mut self, signals: &InputSignals, hw: &mut dyn HardwareBridge) {
-        let mut req = FirmwareRequest {
+        let mut req = PrometeuContext {
+            vm: &mut self.vm,
             os: &mut self.os,
             hub: &mut self.hub,
             signals,
@@ -62,7 +66,8 @@ impl Firmware {
     }
 
     fn on_update(&mut self, signals: &InputSignals, hw: &mut dyn HardwareBridge) -> Option<FirmwareState> {
-        let mut req = FirmwareRequest {
+        let mut req = PrometeuContext {
+            vm: &mut self.vm,
             os: &mut self.os,
             hub: &mut self.hub,
             signals,
@@ -80,7 +85,8 @@ impl Firmware {
     }
 
     fn on_exit(&mut self, signals: &InputSignals, hw: &mut dyn HardwareBridge) {
-        let mut req = FirmwareRequest {
+        let mut req = PrometeuContext {
+            vm: &mut self.vm,
             os: &mut self.os,
             hub: &mut self.hub,
             signals,

crates/prometeu-core/src/firmware/firmware_step_crash_screen.rs

@@ -1,5 +1,5 @@
 use crate::firmware::firmware_state::{FirmwareState, LaunchHubStep};
-use crate::firmware::FirmwareRequest;
+use crate::firmware::prometeu_context::PrometeuContext;
 use crate::model::Color;
 
 #[derive(Debug, Clone)]
@@ -8,25 +8,25 @@ pub struct AppCrashesStep {
 }
 
 impl AppCrashesStep {
-    pub fn on_enter(&mut self, _req: &mut FirmwareRequest) {}
+    pub fn on_enter(&mut self, _ctx: &mut PrometeuContext) {}
 
-    pub fn on_update(&mut self, req: &mut FirmwareRequest) -> Option<FirmwareState> {
+    pub fn on_update(&mut self, ctx: &mut PrometeuContext) -> Option<FirmwareState> {
         // Atualiza periféricos para input na tela de crash
-        req.hw.pad_mut().begin_frame(req.signals);
+        ctx.hw.pad_mut().begin_frame(ctx.signals);
 
         // Tela de erro: fundo vermelho, texto branco
-        req.hw.gfx_mut().clear(Color::RED);
+        ctx.hw.gfx_mut().clear(Color::RED);
         // Por enquanto apenas logamos ou mostramos algo simples
         // No futuro, usar draw_text
-        req.hw.gfx_mut().present();
+        ctx.hw.gfx_mut().present();
 
         // Se apertar START, volta pro Hub
-        if req.hw.pad().start.down {
+        if ctx.hw.pad().start.down {
             return Some(FirmwareState::LaunchHub(LaunchHubStep));
         }
         
         None
     }
 
-    pub fn on_exit(&mut self, _req: &mut FirmwareRequest) {}
+    pub fn on_exit(&mut self, _ctx: &mut PrometeuContext) {}
 }

crates/prometeu-core/src/firmware/firmware_step_hub_home.rs

@@ -1,21 +1,20 @@
 use crate::firmware::firmware_state::FirmwareState;
-use crate::firmware::FirmwareRequest;
-use crate::model::Color;
+use crate::firmware::prometeu_context::PrometeuContext;
 
 #[derive(Debug, Clone)]
 pub struct HubHomeStep;
 
 impl HubHomeStep {
-    pub fn on_enter(&mut self, _req: &mut FirmwareRequest) {}
+    pub fn on_enter(&mut self, _ctx: &mut PrometeuContext) {}
 
-    pub fn on_update(&mut self, req: &mut FirmwareRequest) -> Option<FirmwareState> {
+    pub fn on_update(&mut self, ctx: &mut PrometeuContext) -> Option<FirmwareState> {
         // req.hw.gfx_mut().clear(Color::BLACK);
-        req.hw.pad_mut().begin_frame(req.signals);
-        req.hub.gui_update(req.os, req.hw);
-        req.hw.gfx_mut().present();
+        ctx.hw.pad_mut().begin_frame(ctx.signals);
+        ctx.hub.gui_update(ctx.os, ctx.hw);
+        ctx.hw.gfx_mut().present();
         
         None
     }
 
-    pub fn on_exit(&mut self, _req: &mut FirmwareRequest) {}
+    pub fn on_exit(&mut self, _ctx: &mut PrometeuContext) {}
 }

crates/prometeu-core/src/firmware/firmware_step_init_app.rs

@@ -1,5 +1,5 @@
 use crate::firmware::firmware_state::{FirmwareState, RunAppStep};
-use crate::firmware::FirmwareRequest;
+use crate::firmware::prometeu_context::PrometeuContext;
 use crate::model::Cartridge;
 
 #[derive(Debug, Clone)]
@@ -8,13 +8,13 @@ pub struct InitAppStep {
 }
 
 impl InitAppStep {
-    pub fn on_enter(&mut self, req: &mut FirmwareRequest) {
-        req.os.initialize_vm(&self.cartridge);
+    pub fn on_enter(&mut self, ctx: &mut PrometeuContext) {
+        ctx.os.initialize_vm(ctx.vm, &self.cartridge);
     }
 
-    pub fn on_update(&mut self, _req: &mut FirmwareRequest) -> Option<FirmwareState> {
+    pub fn on_update(&mut self, _ctx: &mut PrometeuContext) -> Option<FirmwareState> {
         Some(FirmwareState::AppRunning(RunAppStep))
     }
 
-    pub fn on_exit(&mut self, _req: &mut FirmwareRequest) {}
+    pub fn on_exit(&mut self, _ctx: &mut PrometeuContext) {}
 }

crates/prometeu-core/src/firmware/firmware_step_launch_hub.rs

@@ -1,17 +1,17 @@
 use crate::firmware::firmware_state::{FirmwareState, HubHomeStep};
-use crate::firmware::FirmwareRequest;
+use crate::firmware::prometeu_context::PrometeuContext;
 
 #[derive(Debug, Clone)]
 pub struct LaunchHubStep;
 
 impl LaunchHubStep {
-    pub fn on_enter(&mut self, req: &mut FirmwareRequest) {
-        req.hub.init();
+    pub fn on_enter(&mut self, ctx: &mut PrometeuContext) {
+        ctx.hub.init();
     }
 
-    pub fn on_update(&mut self, _req: &mut FirmwareRequest) -> Option<FirmwareState> {
+    pub fn on_update(&mut self, _ctx: &mut PrometeuContext) -> Option<FirmwareState> {
         Some(FirmwareState::HubHome(HubHomeStep))
     }
 
-    pub fn on_exit(&mut self, _req: &mut FirmwareRequest) {}
+    pub fn on_exit(&mut self, _ctx: &mut PrometeuContext) {}
 }

crates/prometeu-core/src/firmware/firmware_step_reset.rs

@@ -1,17 +1,17 @@
 use crate::firmware::firmware_state::{FirmwareState, SplashScreenStep};
-use crate::firmware::FirmwareRequest;
+use crate::firmware::prometeu_context::PrometeuContext;
 
 #[derive(Debug, Clone)]
 pub struct ResetStep;
 
 impl ResetStep {
-    pub fn on_enter(&mut self, req: &mut FirmwareRequest) {
-        req.os.reset();
+    pub fn on_enter(&mut self, ctx: &mut PrometeuContext) {
+        ctx.os.reset(ctx.vm);
     }
 
-    pub fn on_update(&mut self, _req: &mut FirmwareRequest) -> Option<FirmwareState> {
+    pub fn on_update(&mut self, _ctx: &mut PrometeuContext) -> Option<FirmwareState> {
         Some(FirmwareState::SplashScreen(SplashScreenStep { frame: 0 }))
     }
 
-    pub fn on_exit(&mut self, _req: &mut FirmwareRequest) {}
+    pub fn on_exit(&mut self, _ctx: &mut PrometeuContext) {}
 }

crates/prometeu-core/src/firmware/firmware_step_run_app.rs

@@ -1,15 +1,15 @@
 use crate::firmware::firmware_state::{AppCrashesStep, FirmwareState};
-use crate::firmware::FirmwareRequest;
+use crate::firmware::prometeu_context::PrometeuContext;
 
 #[derive(Debug, Clone)]
 pub struct RunAppStep;
 
 impl RunAppStep {
-    pub fn on_enter(&mut self, _req: &mut FirmwareRequest) {}
+    pub fn on_enter(&mut self, _ctx: &mut PrometeuContext) {}
 
-    pub fn on_update(&mut self, req: &mut FirmwareRequest) -> Option<FirmwareState> {
-        req.os.step_frame(req.signals, req.hw).map(|err| FirmwareState::AppCrashes(AppCrashesStep { error: err }))
+    pub fn on_update(&mut self, ctx: &mut PrometeuContext) -> Option<FirmwareState> {
+        ctx.os.step_frame(ctx.vm, ctx.signals, ctx.hw).map(|err| FirmwareState::AppCrashes(AppCrashesStep { error: err }))
     }
 
-    pub fn on_exit(&mut self, _req: &mut FirmwareRequest) {}
+    pub fn on_exit(&mut self, _ctx: &mut PrometeuContext) {}
 }

crates/prometeu-core/src/firmware/firmware_step_splash_screen.rs

@@ -1,5 +1,5 @@
 use crate::firmware::firmware_state::{FirmwareState, LaunchHubStep};
-use crate::firmware::FirmwareRequest;
+use crate::firmware::prometeu_context::PrometeuContext;
 use crate::hardware::LoopMode;
 use crate::model::Color;
 
@@ -9,25 +9,25 @@ pub struct SplashScreenStep {
 }
 
 impl SplashScreenStep {
-    pub fn on_enter(&mut self, req: &mut FirmwareRequest) {
+    pub fn on_enter(&mut self, ctx: &mut PrometeuContext) {
         // Tocar som no enter
-        if let Some(sample) = req.os.sample_square.clone() {
-            req.hw.audio_mut().play(sample, 0, 255, 127, 1.0, 0, LoopMode::Off);
+        if let Some(sample) = ctx.os.sample_square.clone() {
+            ctx.hw.audio_mut().play(sample, 0, 255, 127, 1.0, 0, LoopMode::Off);
         }
     }
 
-    pub fn on_update(&mut self, req: &mut FirmwareRequest) -> Option<FirmwareState> {
+    pub fn on_update(&mut self, ctx: &mut PrometeuContext) -> Option<FirmwareState> {
         const ANIMATION_DURATION: u32 = 60; // 1 segundo a 60fps
-        const TOTAL_DURATION: u32 = 240;   // 2 segundos totais (conforme requisito anterior)
+        const TOTAL_DURATION: u32 = 240;   // 2 segundos totais (conforme ctxuisito anterior)
 
         // Atualiza periféricos para input
-        req.hw.pad_mut().begin_frame(req.signals);
+        ctx.hw.pad_mut().begin_frame(ctx.signals);
 
         // Limpar tela
-        req.hw.gfx_mut().clear(Color::BLACK);
+        ctx.hw.gfx_mut().clear(Color::BLACK);
 
         // Desenhar quadrado aumentando
-        let (sw, sh) = req.hw.gfx().size();
+        let (sw, sh) = ctx.hw.gfx().size();
         let max_size = (sw.min(sh) as i32 / 2).max(1);
         
         let current_size = if self.frame < ANIMATION_DURATION {
@@ -39,12 +39,12 @@ impl SplashScreenStep {
         let x = (sw as i32 - current_size) / 2;
         let y = (sh as i32 - current_size) / 2;
         
-        req.hw.gfx_mut().fill_rect(x, y, current_size, current_size, Color::WHITE);
-        req.hw.gfx_mut().present();
+        ctx.hw.gfx_mut().fill_rect(x, y, current_size, current_size, Color::WHITE);
+        ctx.hw.gfx_mut().present();
 
         // Lógica de transição
         // Caso o botão start seja pressionado a qualquer momento depois da animação terminar
-        if self.frame >= ANIMATION_DURATION && req.hw.pad().any() {
+        if self.frame >= ANIMATION_DURATION && ctx.hw.pad().any() {
             return Some(FirmwareState::LaunchHub(LaunchHubStep));
         }
 
@@ -57,5 +57,5 @@ impl SplashScreenStep {
         None
     }
 
-    pub fn on_exit(&mut self, _req: &mut FirmwareRequest) {}
+    pub fn on_exit(&mut self, _ctx: &mut PrometeuContext) {}
 }

crates/prometeu-core/src/firmware/mod.rs

@@ -8,16 +8,8 @@ pub(crate) mod firmware_step_hub_home;
 pub(crate) mod firmware_step_init_app;
 pub(crate) mod firmware_step_run_app;
 pub(crate) mod firmware_step_crash_screen;
+mod prometeu_context;
 
 pub use firmware::Firmware;
-
-use crate::hardware::{HardwareBridge, InputSignals};
-use crate::prometeu_hub::PrometeuHub;
-use crate::prometeu_os::PrometeuOS;
-
-pub struct FirmwareRequest<'a> {
-    pub os: &'a mut PrometeuOS,
-    pub hub: &'a mut PrometeuHub,
-    pub signals: &'a InputSignals,
-    pub hw: &'a mut dyn HardwareBridge,
-}
+pub use firmware_state::FirmwareState;
+pub use prometeu_context::PrometeuContext;

crates/prometeu-core/src/firmware/prometeu_context.rs

@@ -0,0 +1,12 @@
+use crate::hardware::{HardwareBridge, InputSignals};
+use crate::prometeu_hub::PrometeuHub;
+use crate::prometeu_os::PrometeuOS;
+use crate::virtual_machine::VirtualMachine;
+
+pub struct PrometeuContext<'a> {
+    pub vm: &'a mut VirtualMachine,
+    pub os: &'a mut PrometeuOS,
+    pub hub: &'a mut PrometeuHub,
+    pub signals: &'a InputSignals,
+    pub hw: &'a mut dyn HardwareBridge,
+}

crates/prometeu-core/src/prometeu_hub/prometeu_hub.rs

@@ -34,7 +34,7 @@ impl PrometeuHub {
         // Inicializa o Window System e lista apps
     }
 
-    pub fn gui_update(&mut self, os: &mut PrometeuOS, hw: &mut dyn HardwareBridge) {
+    pub fn gui_update(&mut self, _os: &mut PrometeuOS, hw: &mut dyn HardwareBridge) {
         if hw.pad().a.down {
             self.color = Color::GREEN;
         }

crates/prometeu-core/src/prometeu_os/prometeu_os.rs

@@ -1,13 +1,12 @@
-use crate::model::{Cartridge, Color, Sample};
 use crate::hardware::{HardwareBridge, InputSignals};
+use crate::model::{Cartridge, Color, Sample};
+use crate::prometeu_os::NativeInterface;
 use crate::virtual_machine::{Value, VirtualMachine};
 use std::sync::Arc;
-use crate::prometeu_os::NativeInterface;
 
 /// PrometeuOS (POS): O firmware/base do sistema.
 /// Autoridade máxima do boot, periféricos, execução da PVM e tratamento de falhas.
 pub struct PrometeuOS {
-    pub vm: VirtualMachine,
     pub tick_index: u64,
     pub logical_frame_index: u64,
     pub logical_frame_open: bool,
@@ -24,7 +23,6 @@ impl PrometeuOS {
 
     pub fn new() -> Self {
         let mut os = Self {
-            vm: VirtualMachine::default(),
             tick_index: 0,
             logical_frame_index: 0,
             logical_frame_open: false,
@@ -40,8 +38,8 @@ impl PrometeuOS {
         os
     }
 
-    pub fn reset(&mut self) {
-        self.vm = VirtualMachine::default();
+    pub fn reset(&mut self, vm: &mut VirtualMachine) {
+        *vm = VirtualMachine::default();
         self.tick_index = 0;
         self.logical_frame_index = 0;
         self.logical_frame_open = false;
@@ -49,12 +47,12 @@ impl PrometeuOS {
     }
 
     /// Carrega um cartucho na PVM e reseta o estado de execução.
-    pub fn initialize_vm(&mut self, cartridge: &Cartridge) {
-        self.vm.initialize(cartridge.program.clone());
+    pub fn initialize_vm(&mut self, vm: &mut VirtualMachine, cartridge: &Cartridge) {
+        vm.initialize(cartridge.program.clone());
     }
 
     /// Executa um tick do host (60Hz).
-    pub fn step_frame(&mut self, signals: &InputSignals, hw: &mut dyn HardwareBridge) -> Option<String> {
+    pub fn step_frame(&mut self, vm: &mut VirtualMachine, signals: &InputSignals, hw: &mut dyn HardwareBridge) -> Option<String> {
         let start = std::time::Instant::now();
         self.tick_index += 1;
 
@@ -64,9 +62,7 @@ impl PrometeuOS {
         }
 
         // Executa budget
-        let mut vm = std::mem::take(&mut self.vm);
         let run_result = vm.run_budget(Self::CYCLES_PER_FRAME, self, hw);
-        self.vm = vm;
 
         match run_result {
             Ok(run) => {