0.3.0-0-pre.5

crates/apps/game-snake-poc-wasm/Cargo.toml

@@ -1,5 +1,5 @@
 # file: crates/apps/game-snake-poc-wasm/Cargo.toml
-# version: 1
+# version: 2
 
 [package]
 name = "game-snake-poc-wasm"
@@ -15,6 +15,7 @@ crate-type = ["cdylib", "rlib"]
 
 [dependencies]
 engine-v1-common = { path = "../../engines/engine-v1-common" }
+engine-v1-platform-api = { path = "../../engines/engine-v1-platform-api" }
 game-snake-poc = { path = "../../games/game-snake-poc" }
 wasm-bindgen.workspace = true
 

crates/apps/game-snake-poc-wasm/src/runtime.rs

@@ -1,5 +1,5 @@
 // file: crates/apps/game-snake-poc-wasm/src/runtime.rs
-// version: 1
+// version: 2
 
 const FIXED_STEP_MILLIS: u64 = 16;
 
@@ -7,6 +7,7 @@ const FIXED_STEP_MILLIS: u64 = 16;
 #[wasm_bindgen::prelude::wasm_bindgen]
 pub struct SnakeWasmGame {
     pending_input: engine_v1_common::InputState,
+    provenance: engine_v1_platform_api::RuntimeProvenance,
     runner: engine_v1_common::FixedStepRunner,
     state: game_snake_poc::SnakeState,
 }
@@ -18,11 +19,63 @@ impl SnakeWasmGame {
     pub fn new() -> Self {
         return Self {
             pending_input: engine_v1_common::InputState::none(),
+            provenance: engine_v1_platform_api::RuntimeProvenance::new(
+                engine_v1_platform_api::DeviceClass::Unknown,
+                engine_v1_platform_api::ExecutionModel::Wasm,
+                engine_v1_platform_api::InputProfile::Unknown,
+                engine_v1_platform_api::PlatformFamily::Web,
+                engine_v1_platform_api::RuntimeHost::Browser,
+            ),
             runner: engine_v1_common::FixedStepRunner::new(std::time::Duration::from_millis(FIXED_STEP_MILLIS)),
             state: game_snake_poc::SnakeState::new(),
         };
     }
 
+    /// Updates browser-observed device and input dimensions while preserving Web/WASM/Browser provenance.
+    pub fn configure_runtime_provenance(&mut self, device_class: &str, input_profile: &str) -> bool {
+        let device_class = match parse_device_class(device_class) {
+            Some(value) => value,
+            None => return false,
+        };
+        let input_profile = match parse_input_profile(input_profile) {
+            Some(value) => value,
+            None => return false,
+        };
+        self.provenance = engine_v1_platform_api::RuntimeProvenance::new(
+            device_class,
+            engine_v1_platform_api::ExecutionModel::Wasm,
+            input_profile,
+            engine_v1_platform_api::PlatformFamily::Web,
+            engine_v1_platform_api::RuntimeHost::Browser,
+        );
+        return true;
+    }
+
+    /// Returns the current physical device class label.
+    pub fn provenance_device_class(&self) -> String {
+        return device_class_label(self.provenance.device_class()).to_string();
+    }
+
+    /// Returns the current execution model label.
+    pub fn provenance_execution_model(&self) -> String {
+        return execution_model_label(self.provenance.execution_model()).to_string();
+    }
+
+    /// Returns the current primary input profile label.
+    pub fn provenance_input_profile(&self) -> String {
+        return input_profile_label(self.provenance.input_profile()).to_string();
+    }
+
+    /// Returns the current platform family label.
+    pub fn provenance_platform_family(&self) -> String {
+        return platform_family_label(self.provenance.platform_family()).to_string();
+    }
+
+    /// Returns the current runtime host label.
+    pub fn provenance_runtime_host(&self) -> String {
+        return runtime_host_label(self.provenance.runtime_host()).to_string();
+    }
+
     /// Queues a logical left direction for the next deterministic update.
     pub fn left(&mut self) {
         self.queue_direction(engine_v1_common::GameAction::Left);
@@ -183,6 +236,69 @@ impl SnakeWasmGame {
     }
 }
 
+fn parse_device_class(label: &str) -> Option<engine_v1_platform_api::DeviceClass> {
+    return match label {
+        "desktop" => Some(engine_v1_platform_api::DeviceClass::Desktop),
+        "phone" => Some(engine_v1_platform_api::DeviceClass::Phone),
+        "tablet" => Some(engine_v1_platform_api::DeviceClass::Tablet),
+        "unknown" => Some(engine_v1_platform_api::DeviceClass::Unknown),
+        _ => None,
+    };
+}
+
+fn parse_input_profile(label: &str) -> Option<engine_v1_platform_api::InputProfile> {
+    return match label {
+        "gamepad" => Some(engine_v1_platform_api::InputProfile::Gamepad),
+        "keyboard-mouse" => Some(engine_v1_platform_api::InputProfile::KeyboardMouse),
+        "mixed" => Some(engine_v1_platform_api::InputProfile::Mixed),
+        "touch" => Some(engine_v1_platform_api::InputProfile::Touch),
+        "unknown" => Some(engine_v1_platform_api::InputProfile::Unknown),
+        _ => None,
+    };
+}
+
+fn device_class_label(value: engine_v1_platform_api::DeviceClass) -> &'static str {
+    return match value {
+        engine_v1_platform_api::DeviceClass::Desktop => "desktop",
+        engine_v1_platform_api::DeviceClass::Phone => "phone",
+        engine_v1_platform_api::DeviceClass::Tablet => "tablet",
+        engine_v1_platform_api::DeviceClass::Unknown => "unknown",
+    };
+}
+
+fn execution_model_label(value: engine_v1_platform_api::ExecutionModel) -> &'static str {
+    return match value {
+        engine_v1_platform_api::ExecutionModel::Native => "native",
+        engine_v1_platform_api::ExecutionModel::Wasm => "wasm",
+    };
+}
+
+fn input_profile_label(value: engine_v1_platform_api::InputProfile) -> &'static str {
+    return match value {
+        engine_v1_platform_api::InputProfile::Gamepad => "gamepad",
+        engine_v1_platform_api::InputProfile::KeyboardMouse => "keyboard-mouse",
+        engine_v1_platform_api::InputProfile::Mixed => "mixed",
+        engine_v1_platform_api::InputProfile::Touch => "touch",
+        engine_v1_platform_api::InputProfile::Unknown => "unknown",
+    };
+}
+
+fn platform_family_label(value: engine_v1_platform_api::PlatformFamily) -> &'static str {
+    return match value {
+        engine_v1_platform_api::PlatformFamily::Android => "android",
+        engine_v1_platform_api::PlatformFamily::Desktop => "desktop",
+        engine_v1_platform_api::PlatformFamily::Web => "web",
+    };
+}
+
+fn runtime_host_label(value: engine_v1_platform_api::RuntimeHost) -> &'static str {
+    return match value {
+        engine_v1_platform_api::RuntimeHost::Browser => "browser",
+        engine_v1_platform_api::RuntimeHost::Native => "native",
+        engine_v1_platform_api::RuntimeHost::TauriWebView => "tauri-webview",
+    };
+}
+
 #[cfg(test)]
 #[path = "../unit_tests/runtime.rs"]
 mod tests;

crates/apps/game-snake-poc-wasm/unit_tests/runtime.rs

@@ -1,5 +1,5 @@
 // file: crates/apps/game-snake-poc-wasm/unit_tests/runtime.rs
-// version: 1
+// version: 2
 
 #[test]
 fn direction_is_queued_without_advancing_simulation() {
@@ -25,3 +25,28 @@ fn scene_and_status_are_exposed_for_canvas_host() {
     assert_eq!(game.rectangle_x(99), -1.0);
     assert_eq!(game.rectangle_y(99), -1.0);
 }
+
+#[test]
+fn browser_runtime_provenance_preserves_static_and_observed_dimensions() {
+    let mut game = crate::SnakeWasmGame::new();
+    assert_eq!(game.provenance_platform_family(), "web");
+    assert_eq!(game.provenance_execution_model(), "wasm");
+    assert_eq!(game.provenance_runtime_host(), "browser");
+    assert_eq!(game.provenance_device_class(), "unknown");
+    assert_eq!(game.provenance_input_profile(), "unknown");
+    assert!(game.configure_runtime_provenance("phone", "touch"));
+    assert_eq!(game.provenance_device_class(), "phone");
+    assert_eq!(game.provenance_input_profile(), "touch");
+    assert_eq!(game.provenance_platform_family(), "web");
+    assert_eq!(game.provenance_execution_model(), "wasm");
+    assert_eq!(game.provenance_runtime_host(), "browser");
+}
+
+#[test]
+fn invalid_runtime_provenance_labels_are_rejected_without_mutation() {
+    let mut game = crate::SnakeWasmGame::new();
+    assert!(game.configure_runtime_provenance("desktop", "keyboard-mouse"));
+    assert!(!game.configure_runtime_provenance("console", "telepathy"));
+    assert_eq!(game.provenance_device_class(), "desktop");
+    assert_eq!(game.provenance_input_profile(), "keyboard-mouse");
+}