crates/console/prometeu-drivers/src/lib.rs

@@ -13,8 +13,8 @@ pub use crate::audio::{Audio, AudioCommand, Channel, MAX_CHANNELS, OUTPUT_SAMPLE
 pub use crate::frame_composer::{ComposerBuffer, FrameComposer, SceneStatus, SpriteController};
 pub use crate::gfx::Gfx;
 pub use crate::memory_banks::{
-    GlyphBankPoolAccess, GlyphBankPoolInstaller, MemoryBanks, RenderResourceAccess,
+    GlyphBankPoolAccess, GlyphBankPoolInstaller, MemoryBanks, SceneBankPoolAccess,
-    SceneBankPoolAccess, SceneBankPoolInstaller, SoundBankPoolAccess, SoundBankPoolInstaller,
+    SceneBankPoolInstaller, SoundBankPoolAccess, SoundBankPoolInstaller,
 };
 pub use crate::pad::Pad;
 pub use crate::test_platform::TestPlatform;

crates/console/prometeu-drivers/src/memory_banks.rs

@@ -2,11 +2,12 @@
 //!
 //! Render consumers must cross this boundary through small, read-only traits.
 //! Frame packets carry resource IDs; large resident resources stay in banks and
-//! are returned as `Arc` snapshots of the slot contents. Installation and slot
+//! are read in place through a narrow HAL callback contract. Installation and
-//! replacement remain separate owner-side operations and are not part of the
+//! slot replacement remain separate owner-side operations and are not part of
-//! render read surface.
+//! the render read surface.
 
 use prometeu_hal::glyph_bank::GlyphBank;
+use prometeu_hal::render_resources::RenderResourceAccess as HalRenderResourceAccess;
 use prometeu_hal::scene_bank::SceneBank;
 use prometeu_hal::sound_bank::SoundBank;
 use std::sync::{Arc, RwLock};
@@ -53,15 +54,6 @@ pub trait SceneBankPoolInstaller: Send + Sync {
     fn install_scene_bank(&self, slot: usize, bank: Arc<SceneBank>);
 }
 
-/// Read-only resource surface needed by render consumers.
-///
-/// This is intentionally narrower than `MemoryBanks`: render code can resolve
-/// stable packet IDs to resident glyph/scene banks, but cannot install or swap
-/// resources through this trait.
-pub trait RenderResourceAccess: GlyphBankPoolAccess + SceneBankPoolAccess {}
-
-impl<T> RenderResourceAccess for T where T: GlyphBankPoolAccess + SceneBankPoolAccess {}
-
 /// Centralized container for all hardware memory banks.
 ///
 /// MemoryBanks represent the actual hardware slot state.
@@ -150,6 +142,28 @@ impl SceneBankPoolInstaller for MemoryBanks {
     }
 }
 
+impl HalRenderResourceAccess for MemoryBanks {
+    fn with_glyph_bank<R>(&self, bank_id: usize, read: impl FnOnce(&GlyphBank) -> R) -> Option<R> {
+        let pool = self.glyph_bank_pool.read().unwrap();
+        let bank = pool.get(bank_id)?.as_deref()?;
+        Some(read(bank))
+    }
+
+    fn glyph_bank_count(&self) -> usize {
+        16
+    }
+
+    fn with_scene_bank<R>(&self, bank_id: usize, read: impl FnOnce(&SceneBank) -> R) -> Option<R> {
+        let pool = self.scene_bank_pool.read().unwrap();
+        let bank = pool.get(bank_id)?.as_deref()?;
+        Some(read(bank))
+    }
+
+    fn scene_bank_count(&self) -> usize {
+        16
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -193,24 +207,24 @@ mod tests {
         assert_send_sync::<MemoryBanks>();
         assert_send_sync::<Arc<dyn GlyphBankPoolAccess>>();
         assert_send_sync::<Arc<dyn SceneBankPoolAccess>>();
-        assert_send_sync::<Arc<dyn RenderResourceAccess>>();
     }
 
     #[test]
-    fn render_resource_access_exposes_read_only_glyph_and_scene_banks() {
+    fn render_resource_access_exposes_read_only_glyph_and_scene_banks_without_arc_contract() {
-        let banks = Arc::new(MemoryBanks::new());
+        let banks = MemoryBanks::new();
         banks.install_glyph_bank(0, Arc::new(make_glyph_bank()));
         banks.install_scene_bank(1, Arc::new(make_scene_bank()));
 
-        let render_resources: Arc<dyn RenderResourceAccess> = banks;
+        let glyph_tile_size =
-        let glyph_bank =
+            HalRenderResourceAccess::with_glyph_bank(&banks, 0, |bank| bank.tile_size);
-            render_resources.glyph_bank_slot(0).expect("glyph bank slot should be readable");
+        let scene_tile_size =
-        let scene_bank =
+            HalRenderResourceAccess::with_scene_bank(&banks, 1, |bank| bank.layers[0].tile_size);
-            render_resources.scene_bank_slot(1).expect("scene bank slot should be readable");
 
-        assert_eq!(glyph_bank.tile_size, TileSize::Size8);
+        assert_eq!(glyph_tile_size, Some(TileSize::Size8));
-        assert_eq!(scene_bank.layers[0].tile_size, TileSize::Size8);
+        assert_eq!(scene_tile_size, Some(TileSize::Size8));
-        assert!(render_resources.glyph_bank_slot(15).is_none());
+        assert_eq!(HalRenderResourceAccess::with_glyph_bank(&banks, 15, |_| ()), None);
-        assert!(render_resources.scene_bank_slot(15).is_none());
+        assert_eq!(HalRenderResourceAccess::with_scene_bank(&banks, 15, |_| ()), None);
+        assert_eq!(HalRenderResourceAccess::glyph_bank_count(&banks), 16);
+        assert_eq!(HalRenderResourceAccess::scene_bank_count(&banks), 16);
     }
 }

crates/console/prometeu-hal/src/lib.rs

@@ -21,6 +21,7 @@ pub mod owned_frame;
 pub mod pad_bridge;
 pub mod platform;
 pub mod primitives;
+pub mod render_resources;
 pub mod render_submission;
 pub mod sample;
 pub mod scene_bank;
@@ -52,6 +53,7 @@ pub use platform::{
     NoopTelemetryPlatform, RenderBackend, RenderSubmissionSink, RenderSubmitError, RuntimePlatform,
     TelemetryPlatform, TestPlatform,
 };
+pub use render_resources::RenderResourceAccess;
 pub use render_submission::{
     BoundScenePacket, Camera2D, ComposerFramePacket, FrameId, Game2DFramePacket, GameSpritePacket,
     Gfx2dCommand, GfxUiCommand, HudCommand, HudPacket, RenderOwnership, RenderSubmission,

crates/console/prometeu-hal/src/render_resources.rs

@@ -0,0 +1,109 @@
+use crate::glyph_bank::GlyphBank;
+use crate::scene_bank::SceneBank;
+
+/// Read-only render resource lookup used by render backends.
+///
+/// Resource ids are stable bank slots carried by render submissions. The
+/// callback shape keeps bank ownership inside the provider while exposing only
+/// borrowed read access to the caller.
+pub trait RenderResourceAccess {
+    /// Reads a resident glyph bank by id.
+    fn with_glyph_bank<R>(&self, bank_id: usize, read: impl FnOnce(&GlyphBank) -> R) -> Option<R>;
+
+    /// Returns the number of glyph bank ids accepted by this provider.
+    fn glyph_bank_count(&self) -> usize;
+
+    /// Reads a resident scene bank by id.
+    fn with_scene_bank<R>(&self, bank_id: usize, read: impl FnOnce(&SceneBank) -> R) -> Option<R>;
+
+    /// Returns the number of scene bank ids accepted by this provider.
+    fn scene_bank_count(&self) -> usize;
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::glyph::Glyph;
+    use crate::glyph_bank::TileSize;
+    use crate::scene_layer::{ParallaxFactor, SceneLayer};
+    use crate::tile::Tile;
+    use crate::tilemap::TileMap;
+
+    struct TestRenderResources {
+        glyph_banks: Vec<Option<GlyphBank>>,
+        scene_banks: Vec<Option<SceneBank>>,
+    }
+
+    impl RenderResourceAccess for TestRenderResources {
+        fn with_glyph_bank<R>(
+            &self,
+            bank_id: usize,
+            read: impl FnOnce(&GlyphBank) -> R,
+        ) -> Option<R> {
+            self.glyph_banks.get(bank_id)?.as_ref().map(read)
+        }
+
+        fn glyph_bank_count(&self) -> usize {
+            self.glyph_banks.len()
+        }
+
+        fn with_scene_bank<R>(
+            &self,
+            bank_id: usize,
+            read: impl FnOnce(&SceneBank) -> R,
+        ) -> Option<R> {
+            self.scene_banks.get(bank_id)?.as_ref().map(read)
+        }
+
+        fn scene_bank_count(&self) -> usize {
+            self.scene_banks.len()
+        }
+    }
+
+    fn scene_bank(tile_size: TileSize) -> SceneBank {
+        let layer = SceneLayer {
+            active: true,
+            glyph_asset_id: 7,
+            tile_size,
+            parallax_factor: ParallaxFactor { x: 1.0, y: 1.0 },
+            tilemap: TileMap {
+                width: 1,
+                height: 1,
+                tiles: vec![Tile {
+                    active: true,
+                    glyph: Glyph { glyph_id: 3, palette_id: 0 },
+                    flip_x: false,
+                    flip_y: false,
+                }],
+            },
+        };
+
+        SceneBank { layers: std::array::from_fn(|_| layer.clone()) }
+    }
+
+    #[test]
+    fn reads_resident_resources_by_id() {
+        let resources = TestRenderResources {
+            glyph_banks: vec![None, Some(GlyphBank::new(TileSize::Size16, 16, 16)), None],
+            scene_banks: vec![Some(scene_bank(TileSize::Size8)), None],
+        };
+
+        assert_eq!(resources.glyph_bank_count(), 3);
+        assert_eq!(resources.scene_bank_count(), 2);
+        assert_eq!(resources.with_glyph_bank(1, |bank| bank.tile_size), Some(TileSize::Size16));
+        assert_eq!(
+            resources.with_scene_bank(0, |bank| bank.layers[0].tile_size),
+            Some(TileSize::Size8)
+        );
+    }
+
+    #[test]
+    fn missing_resources_return_none() {
+        let resources = TestRenderResources { glyph_banks: vec![None], scene_banks: vec![None] };
+
+        assert_eq!(resources.with_glyph_bank(0, |bank| bank.width), None);
+        assert_eq!(resources.with_glyph_bank(9, |bank| bank.width), None);
+        assert_eq!(resources.with_scene_bank(0, |bank| bank.layers[0].active), None);
+        assert_eq!(resources.with_scene_bank(9, |bank| bank.layers[0].active), None);
+    }
+}

discussion/workflow/plans/PLN-0111-define-read-only-render-resource-access.md

@@ -2,7 +2,7 @@
 id: PLN-0111
 ticket: real-render-worker-establishment
 title: Define Read-Only Render Resource Access
-status: open
+status: done
 created: 2026-06-15
 completed:
 ref_decisions: [DEC-0033]