From b63fc4d1b181530909690f4aef2d953e707d889d Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Fri, 8 May 2026 09:32:30 -0500
Subject: [PATCH 01/36] feat: move TileLayer grid methods into separate type &
 add resizing methods

---
 .../bones_framework/src/render/tilemap.rs     | 175 +++++++++++++++---
 1 file changed, 145 insertions(+), 30 deletions(-)

diff --git a/framework_crates/bones_framework/src/render/tilemap.rs b/framework_crates/bones_framework/src/render/tilemap.rs
index 2da156303b..a3a28df04d 100644
--- a/framework_crates/bones_framework/src/render/tilemap.rs
+++ b/framework_crates/bones_framework/src/render/tilemap.rs
@@ -2,18 +2,36 @@
 
 use crate::prelude::*;
 
-/// A tilemap layer component.
+/// Used for mapping entities to a sized grid. This is used in the [`TileLayer`]
+/// component for mapping entities with [`Tile`] components to it.
 #[derive(Clone, Debug, HasSchema, Default)]
-pub struct TileLayer {
+pub struct EntityGridMap {
     /// The vector of tile slots in this layer.
     pub tiles: Vec<Option<Entity>>,
-    /// The size of the layer in tiles.
+    /// The size of the map in tiles (or columns and rows).
     pub grid_size: UVec2,
     /// The size of each tile in the layer.
     pub tile_size: Vec2,
+}
+
+/// A tilemap layer component.
+#[derive(Clone, Debug, HasSchema, Default, Deref, DerefMut)]
+pub struct TileLayer {
+    #[deref]
+    /// The grid map for this [`TileLayer`]'s [`Tile`]s.
+    pub map: EntityGridMap,
     /// The texture atlas to use for the layer
     pub atlas: Handle<Atlas>,
 }
+impl TileLayer {
+    /// Create a new [`TileLayer`].
+    pub fn new(grid_size: UVec2, tile_size: Vec2, atlas: Handle<Atlas>) -> Self {
+        Self {
+            map: EntityGridMap::new(grid_size, tile_size),
+            atlas,
+        }
+    }
+}
 
 /// A tilemap tile component.
 #[derive(Clone, Debug, HasSchema, Default)]
@@ -27,60 +45,157 @@ pub struct Tile {
     pub flip_y: bool,
 }
 
-impl TileLayer {
+impl EntityGridMap {
     /// Create a new tile layer
-    pub fn new(grid_size: UVec2, tile_size: Vec2, atlas: Handle<Atlas>) -> Self {
+    pub fn new(grid_size: UVec2, tile_size: Vec2) -> Self {
         let mut out = Self {
             tiles: Vec::new(),
             grid_size,
             tile_size,
-            atlas,
         };
         out.ensure_space();
         out
     }
 
-    /// Makes sure the tiles vector has space for all of our tiles.
-    fn ensure_space(&mut self) {
-        let tile_count = (self.grid_size.x * self.grid_size.y) as usize;
+    /// Get the overall world size
+    pub fn size(&self) -> Vec2 {
+        self.grid_size.as_vec2() * self.tile_size
+    }
 
-        if unlikely(self.tiles.len() < tile_count) {
-            self.tiles
-                .extend((0..(tile_count - self.tiles.len())).map(|_| None));
-        }
+    /// Get's the entity at the given position in the grid if set, indexed with
+    /// the bottom-left of the grid being (0, 0).
+    ///
+    /// Returns `None` is no `Entity` assigned to that position.
+    ///
+    /// Panics if the position is out of the grid bounds.
+    pub fn get(&self, pos: UVec2) -> Option<Entity> {
+        let idx = self.index(pos);
+        self.tiles.get(idx as usize).cloned().flatten()
     }
 
-    /// Get the index of the tile at the given position.
-    #[inline]
-    pub fn idx(&self, pos: UVec2) -> u32 {
-        self.grid_size.x * pos.y + pos.x
+    /// Get's the entity at the given position in the grid if set, indexed with
+    /// the bottom-left of the grid being (0, 0).
+    ///
+    /// Returns `None` if the position is out of the grid bounds or there is no
+    /// `Entity` assigned to that position.
+    pub fn try_get(&self, pos: UVec2) -> Option<Entity> {
+        self.try_index(pos).and_then(|idx| self.tiles[idx as usize])
     }
 
-    /// Get the position of the tile at the given index.
+    /// Get the position on the grid with the given entity index.
+    ///
+    /// Panics if the index is out of the grid bounds.
     pub fn pos(&self, idx: u32) -> UVec2 {
+        if idx as usize >= self.tiles.len() {
+            panic!("index out of grid bounds")
+        }
         let y = idx / self.grid_size.x;
         let x = idx - (y * self.grid_size.x);
 
         UVec2::new(x, y)
     }
+    /// Try to get the position on the grid with the given entity index.
+    ///
+    /// Returns `None` if the index is out of the grid bounds.
+    pub fn try_pos(&self, idx: u32) -> Option<UVec2> {
+        if idx as usize >= self.tiles.len() {
+            None
+        } else {
+            let y = idx / self.grid_size.x;
+            let x = idx - (y * self.grid_size.x);
 
-    /// Get's the tile at the given position in the layer, indexed with the bottom-left of the layer
-    /// being (0, 0).
-    pub fn get(&self, pos: UVec2) -> Option<Entity> {
-        let idx = self.idx(pos);
-        self.tiles.get(idx as usize).cloned().flatten()
+            UVec2::new(x, y).into()
+        }
+    }
+
+    /// Get the index of the tile at the given position.
+    #[inline]
+    #[track_caller]
+    pub fn index(&self, pos: UVec2) -> u32 {
+        if pos.x + 1 > self.grid_size.x || pos.y + 1 > self.grid_size.y {
+            panic!("grid postion out of bounds")
+        }
+        self.grid_size.x * pos.y + pos.x
+    }
+    /// Try to get the index of the tile at the given position.
+    #[inline]
+    pub fn try_index(&self, pos: UVec2) -> Option<u32> {
+        if pos.x + 1 > self.grid_size.x || pos.y + 1 > self.grid_size.y {
+            None
+        } else {
+            Some(self.grid_size.x * pos.y + pos.x)
+        }
     }
 
     /// Set the tile at the given position, to a certain entity.
     pub fn set(&mut self, pos: UVec2, entity: Option<Entity>) {
         self.ensure_space();
 
-        let idx = self.idx(pos);
-        *self.tiles.get_mut(idx as usize).unwrap_or_else(|| {
-            panic!(
-                "Tile pos out of range of tile size: pos {:?} size {:?}",
-                pos, self.grid_size
-            )
-        }) = entity;
+        let idx = self.index(pos);
+        self.tiles[idx as usize] = entity;
+    }
+
+    /// Makes sure the tiles vector has space for all of our tiles.
+    fn ensure_space(&mut self) {
+        let tile_count = (self.grid_size.x * self.grid_size.y) as usize;
+
+        if unlikely(self.tiles.len() < tile_count) {
+            self.tiles
+                .extend((0..(tile_count - self.tiles.len())).map(|_| None));
+        }
+    }
+
+    /// Set a tile position, resizing the map to accommodate the new tile if the map grid is not
+    /// already large enough.
+    pub fn set_with_resize(&mut self, pos: UVec2, entity: Option<Entity>) {
+        // Calculate whatever size is larger, the grid size, or the size needed to store the tile
+        // position.
+        let required_grid_size = self.grid_size.max(pos + UVec2::ONE);
+
+        // If the larger size is not the grid size we have currently
+        if required_grid_size != self.grid_size {
+            // Resize the grid to fit the position
+            self.resize_grid(required_grid_size);
+        }
+
+        // Set the tile position
+        self.set(pos, entity)
+    }
+
+    /// Copy all the tiles from another tileset into this one.
+    ///
+    /// This can be useful for resizing a map, for example.
+    ///
+    /// The tiles from the other layer are copied to the corresponding positions in this layer, if
+    /// they fit into this layer's size.
+    pub fn copy_from(&mut self, other: &EntityGridMap) {
+        // Get the smallest size so that we know we won't go out of bounds while iterating over the
+        // tiles.
+        let visit_size = other.grid_size.min(self.grid_size);
+
+        // Iterate over every position
+        for x in 0..visit_size.x {
+            for y in 0..visit_size.y {
+                let pos = uvec2(x, y);
+                // Set the position in this layer from the position in the other layer
+                self.set(pos, other.get(pos))
+            }
+        }
+    }
+
+    /// Resize the layer, setting a new grid size.
+    ///
+    /// If shrinking the layer, tiles that are out-of-bounds will be removed.
+    pub fn resize_grid(&mut self, grid_size: UVec2) {
+        // Create a new layer with the desired grid size
+        let mut new_layer = EntityGridMap::new(grid_size, self.tile_size);
+
+        // Copy the tiles from this layer into the new one
+        new_layer.copy_from(self);
+
+        // Swap out the new layer and the current one
+        std::mem::swap(self, &mut new_layer);
     }
 }
+
+// TODO: add tests for EntityGridMap

From 336cea4f2ad13354d620249e2f93e264fd9c5674 Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Sun, 10 May 2026 15:42:16 -0500
Subject: [PATCH 02/36] refactor: move startup systems to `SystemStage` out of
 `SystemStages`.

Maintains the rollback & reset compatibility. Deprecates the `add_startup_system` method.
---
 demos/features/src/main.rs                    |  10 +-
 demos/scripting/assets/plugin1.plugin.lua     |   2 +-
 demos/scripting/src/main.rs                   |   5 +-
 .../bones_ecs/examples/pos_vel.rs             |   2 +-
 framework_crates/bones_ecs/src/stage.rs       | 176 ++++++++----------
 .../bones_framework/tests/reset.rs            |   2 +-
 framework_crates/bones_lib/src/lib.rs         |   9 +-
 framework_crates/bones_lib/src/reset.rs       |   3 -
 framework_crates/bones_scripting/src/lua.rs   |  16 +-
 .../bones_scripting/src/lua/asset.rs          |  20 --
 .../bones_scripting/src/lua/bindings.rs       |   1 +
 .../src/lua/bindings/schema.rs                |   7 +
 12 files changed, 106 insertions(+), 147 deletions(-)

diff --git a/demos/features/src/main.rs b/demos/features/src/main.rs
index 51e4380b9d..85a0968b24 100644
--- a/demos/features/src/main.rs
+++ b/demos/features/src/main.rs
@@ -150,7 +150,7 @@ pub fn menu_plugin(session: &mut SessionBuilder) {
     // And add our systems.
     session
         .add_system_to_stage(Update, menu_system)
-        .add_startup_system(menu_startup);
+        .add_system_to_stage(CoreStage::Startup, menu_startup);
 }
 
 /// Setup the main menu.
@@ -283,7 +283,7 @@ fn menu_system(
 fn sprite_demo_plugin(session: &mut SessionBuilder) {
     session
         .install_plugin(DefaultSessionPlugin)
-        .add_startup_system(sprite_demo_startup)
+        .add_system_to_stage(CoreStage::Startup, sprite_demo_startup)
         .add_system_to_stage(Update, back_to_menu_ui)
         .add_system_to_stage(Update, move_sprite);
 }
@@ -347,7 +347,7 @@ fn move_sprite(
 fn tilemap_demo_plugin(session: &mut SessionBuilder) {
     session
         .install_plugin(DefaultSessionPlugin)
-        .add_startup_system(tilemap_startup_system)
+        .add_system_to_stage(CoreStage::Startup, tilemap_startup_system)
         .add_system_to_stage(Update, back_to_menu_ui);
 }
 
@@ -393,7 +393,7 @@ fn tilemap_startup_system(
 fn atlas_demo_plugin(session: &mut SessionBuilder) {
     session
         .install_plugin(DefaultSessionPlugin)
-        .add_startup_system(atlas_demo_startup)
+        .add_system_to_stage(CoreStage::Startup, atlas_demo_startup)
         .add_system_to_stage(Update, back_to_menu_ui);
 }
 
@@ -497,7 +497,7 @@ fn storage_demo_ui(
 fn path2d_demo_plugin(session: &mut SessionBuilder) {
     session
         .install_plugin(DefaultSessionPlugin)
-        .add_startup_system(path2d_demo_startup)
+        .add_system_to_stage(CoreStage::Startup, path2d_demo_startup)
         .add_system_to_stage(Update, back_to_menu_ui);
 }
 
diff --git a/demos/scripting/assets/plugin1.plugin.lua b/demos/scripting/assets/plugin1.plugin.lua
index 91f34e8229..ff0273b1ea 100644
--- a/demos/scripting/assets/plugin1.plugin.lua
+++ b/demos/scripting/assets/plugin1.plugin.lua
@@ -30,5 +30,5 @@ local function update()
   end
 end
 
-session:add_startup_system(startup)
+session:add_system_to_stage(CoreStage.Startup, startup)
 session:add_system_to_stage(CoreStage.Update, update)
diff --git a/demos/scripting/src/main.rs b/demos/scripting/src/main.rs
index 8ada4088c8..cfcad810f1 100644
--- a/demos/scripting/src/main.rs
+++ b/demos/scripting/src/main.rs
@@ -19,11 +19,12 @@ fn main() {
     game.install_plugin(DefaultGamePlugin);
     game.shared_resource_mut::<AssetServer>()
         .register_default_assets();
+    Transform::register_schema();
     GameMeta::register_schema();
 
     game.sessions
         .create_with("launch", |builder: &mut SessionBuilder| {
-            builder.add_startup_system(launch_game_session);
+            builder.add_system_to_stage(CoreStage::Startup, launch_game_session);
         });
 
     let mut renderer = BonesBevyRenderer::new(game);
@@ -50,7 +51,7 @@ fn launch_game_session(
                 // Tell it to install the lua plugins specified in our game meta
                 Arc::new(meta.plugins.iter().copied().collect()),
             ))
-            .add_startup_system(game_startup);
+            .add_system_to_stage(CoreStage::Startup, game_startup);
     });
 }
 
diff --git a/framework_crates/bones_ecs/examples/pos_vel.rs b/framework_crates/bones_ecs/examples/pos_vel.rs
index 6d4f52ea2d..31dbbcddf1 100644
--- a/framework_crates/bones_ecs/examples/pos_vel.rs
+++ b/framework_crates/bones_ecs/examples/pos_vel.rs
@@ -27,7 +27,7 @@ fn main() {
 
     // Add our systems to the system stages
     stages_builder
-        .add_startup_system(startup_system)
+        .add_system_to_stage(CoreStage::Startup, startup_system)
         .add_system_to_stage(CoreStage::Update, pos_vel_system)
         .add_system_to_stage(CoreStage::PostUpdate, print_system);
 
diff --git a/framework_crates/bones_ecs/src/stage.rs b/framework_crates/bones_ecs/src/stage.rs
index f5a4db2c86..2e13cb92c1 100644
--- a/framework_crates/bones_ecs/src/stage.rs
+++ b/framework_crates/bones_ecs/src/stage.rs
@@ -15,9 +15,6 @@ pub struct CurrentSystemStage(pub Ulid);
 pub struct SystemStagesBuilder {
     /// The stages in the collection, in the order that they will be run.
     stages: Vec<Box<dyn SystemStage>>,
-    /// The systems that should run at startup.
-    /// They will be executed next step based on if [`SessionStarted`] resource in world says session has not started, or if resource does not exist.
-    startup_systems: Vec<StaticSystem<(), ()>>,
 
     /// Resources installed during session plugin installs. Copied to world as first step on startup of stages' execution.
     startup_resources: UntypedResourceSet,
@@ -37,6 +34,7 @@ impl SystemStagesBuilder {
     pub fn with_core_stages() -> Self {
         Self {
             stages: vec![
+                Box::new(StartupSystemStage::new(CoreStage::Startup)),
                 Box::new(SimpleSystemStage::new(CoreStage::First)),
                 Box::new(SimpleSystemStage::new(CoreStage::PreUpdate)),
                 Box::new(SimpleSystemStage::new(CoreStage::Update)),
@@ -44,7 +42,6 @@ impl SystemStagesBuilder {
                 Box::new(SimpleSystemStage::new(CoreStage::Last)),
             ],
             startup_resources: default(),
-            startup_systems: default(),
             single_success_systems: Vec::new(),
         }
     }
@@ -53,7 +50,6 @@ impl SystemStagesBuilder {
     pub fn finish(self) -> SystemStages {
         SystemStages {
             stages: self.stages,
-            startup_systems: self.startup_systems,
             startup_resources: self.startup_resources,
             single_success_systems: self.single_success_systems,
         }
@@ -63,19 +59,20 @@ impl SystemStagesBuilder {
     pub fn from_stages(stages: SystemStages) -> Self {
         Self {
             stages: stages.stages,
-            startup_systems: stages.startup_systems,
             startup_resources: stages.startup_resources,
             single_success_systems: stages.single_success_systems,
         }
     }
 
-    /// Add a system that will run only once, before all of the other non-startup systems.
-    /// If wish to reset session and run again, can modify [`SessionStarted`] resource in world.
+    /// Add a system to the [`CoreStage::Startup`] stage which specially runs
+    /// only once, before all other core stages. Inserting [`StartupSystemsRan`]
+    /// into the world prevents systems in the startup stage from running.
+    #[deprecated = "use `.add_system_to_stage(CoreStage::Startup, your_system)` instead"]
     pub fn add_startup_system<Args, S>(&mut self, system: S) -> &mut Self
     where
         S: IntoSystem<Args, (), (), Sys = StaticSystem<(), ()>>,
     {
-        self.startup_systems.push(system.system());
+        self.add_system_to_stage(CoreStage::Startup, system.system());
         self
     }
 
@@ -171,10 +168,6 @@ pub struct SystemStages {
     /// The stages in the collection, in the order that they will be run.
     stages: Vec<Box<dyn SystemStage>>,
 
-    /// The systems that should run at startup.
-    /// They will be executed next step based on if [`SessionStarted`] resource in world says session has not started, or if resource does not exist.
-    startup_systems: Vec<StaticSystem<(), ()>>,
-
     /// Resources installed during session plugin installs. Copied to world as first step on startup of stages' execution.
     startup_resources: UntypedResourceSet,
 
@@ -206,8 +199,8 @@ impl SystemStages {
 
     /// Execute the systems on the given `world`.
     pub fn run(&mut self, world: &mut World) {
-        // If we haven't run startup systems and setup resources yet, do so
-        self.handle_startup(world);
+        // If we haven't setup resources yet, do so
+        self.handle_startup_resources(world);
 
         // Run single success systems
         for (index, system) in self.single_success_systems.iter_mut().enumerate() {
@@ -234,87 +227,18 @@ impl SystemStages {
         world.resources.remove::<CurrentSystemStage>();
     }
 
-    /// If [`SessionStarted`] resource indicates have not yet started,
-    /// perform startup tasks (insert startup resources, run startup systems).
-    ///
-    /// For advanced use cases in which want to only insert startup resources, or run startup systems and split this
-    /// behavior, see [`SystemStages::handle_startup_systems`] and `[SystemStages::handle_startup_resources`].
-    ///
-    ///
-    /// While this is used internally by [`SystemStages::run`], this is also used
-    /// for resetting world. This allows world to immediately startup and re-initialize after reset.
-    ///
-    /// # Panics
-    ///
-    /// May panic if resources are borrowed, should not borrow resources when calling.
-    pub fn handle_startup(&mut self, world: &mut World) {
-        self.handle_startup_resources(world);
-        self.handle_startup_systems(world);
-    }
-
-    /// If [`SessionStarted`] resource indicates startup resources have not yet been inserted, will do so and update `SessionStarted`.
-    ///
-    /// This function contains only half of stage's startup behavior, see [`SystemStages::handle_startup`] if not intending to split
-    /// resource insertion from startup systems (Splitting these is more for advanced special cases).
+    /// If [`StartupResourcesInserted`] resource has not yet been inserted, will do so.
     ///
     /// # Panics
     ///
     /// May panic if resources are borrowed, should not borrow resources when calling.
     pub fn handle_startup_resources(&mut self, world: &mut World) {
-        let (mut resources_inserted, systems_run) = match world.get_resource_mut::<SessionStarted>()
-        {
-            Some(session_started) => (
-                session_started.startup_resources_inserted,
-                session_started.startup_systems_executed,
-            ),
-            None => (false, false),
-        };
+        let inserted = world.get_resource::<StartupResourcesInserted>().is_some();
 
-        if !resources_inserted {
+        if !inserted {
             self.insert_startup_resources(world);
-            resources_inserted = true;
 
-            world.insert_resource(SessionStarted {
-                startup_systems_executed: systems_run,
-                startup_resources_inserted: resources_inserted,
-            });
-        }
-    }
-
-    /// If [`SessionStarted`] resource indicates startup systems have not yet been executed, will do so and update `SessionStarted`.
-    ///
-    /// This function contains only half of stage's startup behavior, see [`SystemStages::handle_startup`] if not intending to split
-    /// startup system execution from startup resource insertion (Splitting these is more for advanced special cases).
-    ///
-    /// # Panics
-    ///
-    /// May panic if resources are borrowed, should not borrow resources when calling.
-    pub fn handle_startup_systems(&mut self, world: &mut World) {
-        let (resources_inserted, mut systems_run) = match world.get_resource_mut::<SessionStarted>()
-        {
-            Some(session_started) => (
-                session_started.startup_resources_inserted,
-                session_started.startup_systems_executed,
-            ),
-            None => (false, false),
-        };
-
-        if !systems_run {
-            // Set the current stage resource
-            world.insert_resource(CurrentSystemStage(Ulid(0)));
-
-            // For each startup system
-            for system in &mut self.startup_systems {
-                // Run the system
-                system.run(world, ());
-            }
-            systems_run = true;
-
-            world.resources.remove::<CurrentSystemStage>();
-            world.insert_resource(SessionStarted {
-                startup_systems_executed: systems_run,
-                startup_resources_inserted: resources_inserted,
-            });
+            world.insert_resource(StartupResourcesInserted);
         }
     }
 
@@ -431,6 +355,68 @@ impl SystemStage for SimpleSystemStage {
     }
 }
 
+/// Resource for tracking whether or not the game has run the startup systems in
+/// the [`StartupSystemStage`].
+#[derive(HasSchema, Clone, Default, Debug)]
+pub struct StartupSystemsRan;
+
+/// [`SystemStage`] for running systems once on startup.
+pub struct StartupSystemStage {
+    /// The unique identifier for the stage.
+    pub id: Ulid,
+    /// The human-readable name for the stage, used for error messages when something goes wrong.
+    pub name: String,
+    /// The list of systems in the stage.
+    ///
+    /// Each system will be run in the order that they are in in this list.
+    pub systems: Vec<StaticSystem<(), ()>>,
+}
+impl StartupSystemStage {
+    /// Create a new, empty stage, for the given label.
+    pub fn new<L: StageLabel>(label: L) -> Self {
+        Self {
+            id: label.id(),
+            name: label.name(),
+            systems: Default::default(),
+        }
+    }
+}
+impl SystemStage for StartupSystemStage {
+    fn id(&self) -> Ulid {
+        self.id
+    }
+
+    fn name(&self) -> String {
+        self.name.clone()
+    }
+
+    fn run(&mut self, world: &World) {
+        if world.get_resource_mut::<StartupSystemsRan>().is_none() {
+            // Run the systems
+            for system in &mut self.systems {
+                system.run(world, ());
+            }
+            world.insert_resource(StartupSystemsRan);
+        }
+
+        // Drain the command queue
+        let queue = world.resources.get_mut::<CommandQueue>();
+        if let Some(mut command_queue) = queue {
+            for mut system in command_queue.queue.drain(..) {
+                system.run(world, ());
+            }
+        }
+    }
+
+    fn add_system(&mut self, system: StaticSystem<(), ()>) {
+        self.systems.push(system);
+    }
+
+    fn remove_all_systems(&mut self) {
+        self.systems.clear();
+    }
+}
+
 /// Trait for things that may be used to identify a system stage.
 pub trait StageLabel {
     /// Returns the human-readable name of the label, used in error messages.
@@ -442,6 +428,8 @@ pub trait StageLabel {
 /// A [`StageLabel`] for the 5 core stages.
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum CoreStage {
+    /// The startup stage
+    Startup,
     /// The first stage
     First,
     /// The second stage
@@ -461,6 +449,7 @@ impl StageLabel for CoreStage {
 
     fn id(&self) -> Ulid {
         match self {
+            CoreStage::Startup => Ulid(2149923225027836290977818907354065512),
             CoreStage::First => Ulid(2021715391084198804812356024998495966),
             CoreStage::PreUpdate => Ulid(2021715401330719559452824437611089988),
             CoreStage::Update => Ulid(2021715410160177201728645950400543948),
@@ -526,17 +515,12 @@ impl<'a> SystemParam for Commands<'a> {
     }
 }
 
-/// Resource tracking if Session has started (startup systems executed and resources inserted).
+/// Have startup resources beeen inserted into [`World`]?
+///
 /// If field is set to false, that operation needs to be handled on next stage run.
 /// If resource is not present, assumed to have not started (and will be initialized upon next stage execution).
 #[derive(Copy, Clone, HasSchema, Default)]
-pub struct SessionStarted {
-    /// Have startup systems executed?
-    pub startup_systems_executed: bool,
-
-    /// Have startup resources beeen inserted into [`World`]?
-    pub startup_resources_inserted: bool,
-}
+pub struct StartupResourcesInserted;
 
 /// Resource tracking which of single success systems in `Session`'s [`SystemStages`] have completed.
 /// Success is tracked to
diff --git a/framework_crates/bones_framework/tests/reset.rs b/framework_crates/bones_framework/tests/reset.rs
index 698730c398..7a0031a1f5 100644
--- a/framework_crates/bones_framework/tests/reset.rs
+++ b/framework_crates/bones_framework/tests/reset.rs
@@ -13,7 +13,7 @@ pub fn startup_system_reset() {
     // Session startup increments counter by 1
     game.sessions
         .create_with("game", |builder: &mut SessionBuilder| {
-            builder.add_startup_system(|mut counter: ResMut<Counter>| {
+            builder.add_system_to_stage(Startup, |mut counter: ResMut<Counter>| {
                 // Increment to 1
                 counter.0 += 1;
             });
diff --git a/framework_crates/bones_lib/src/lib.rs b/framework_crates/bones_lib/src/lib.rs
index 8f28f5e915..407ce6cc0f 100644
--- a/framework_crates/bones_lib/src/lib.rs
+++ b/framework_crates/bones_lib/src/lib.rs
@@ -136,13 +136,16 @@ impl SessionBuilder {
         self.stages.startup_resource_mut::<T>()
     }
 
-    /// Add a system that will run only once, before all of the other non-startup systems.
-    /// If wish to reset startup systems during gameplay and run again, can modify [`SessionStarted`] resource in world.
+    /// Add a system to the [`CoreStage::Startup`] stage which specially runs
+    /// only once, before all other core stages. Inserting [`StartupSystemsRan`]
+    /// into the world prevents systems in the startup stage from running.
+    #[deprecated = "use `add_system_to_stage(CoreStage::Startup, your_system)` instead"]
     pub fn add_startup_system<Args, S>(&mut self, system: S) -> &mut Self
     where
         S: IntoSystem<Args, (), (), Sys = StaticSystem<(), ()>>,
     {
-        self.stages.add_startup_system(system.system());
+        self.stages
+            .add_system_to_stage(CoreStage::Startup, system.system());
         self
     }
 
diff --git a/framework_crates/bones_lib/src/reset.rs b/framework_crates/bones_lib/src/reset.rs
index 2a9ddb6a14..e4cf1ed831 100644
--- a/framework_crates/bones_lib/src/reset.rs
+++ b/framework_crates/bones_lib/src/reset.rs
@@ -110,8 +110,5 @@ impl WorldExt for World {
             let remove_empty = true;
             resources.insert_on_world(self, remove_empty);
         }
-
-        // Now run the startup systems after updating resources.
-        stages.handle_startup_systems(self);
     }
 }
diff --git a/framework_crates/bones_scripting/src/lua.rs b/framework_crates/bones_scripting/src/lua.rs
index 414eb27423..b306120982 100644
--- a/framework_crates/bones_scripting/src/lua.rs
+++ b/framework_crates/bones_scripting/src/lua.rs
@@ -51,6 +51,7 @@ impl SessionPlugin for LuaPluginLoaderSessionPlugin {
         session.insert_resource(LuaPlugins(self.0));
 
         for lua_stage in [
+            CoreStage::Startup,
             CoreStage::First,
             CoreStage::PreUpdate,
             CoreStage::Update,
@@ -87,21 +88,6 @@ impl SessionPlugin for LuaPluginLoaderSessionPlugin {
                                 let mut systems = plugin.systems.borrow_mut();
                                 let systems = systems.as_loaded_mut();
 
-                                for (has_run, closure) in &mut systems.startup {
-                                    if !*has_run {
-                                        let executor = lua.enter(|ctx| {
-                                            let closure = ctx.registry().fetch(closure);
-                                            let ex = Executor::start(ctx, closure.into(), ());
-                                            ctx.registry().stash(&ctx, ex)
-                                        });
-                                        if let Err(e) = lua.execute::<()>(&executor) {
-                                            tracing::error!("Error running lua plugin system: {e}");
-                                        }
-
-                                        *has_run = true;
-                                    }
-                                }
-
                                 for (stage, closure) in &systems.core_stages {
                                     if stage == &lua_stage {
                                         let executor = lua.enter(|ctx| {
diff --git a/framework_crates/bones_scripting/src/lua/asset.rs b/framework_crates/bones_scripting/src/lua/asset.rs
index ac3b4b661a..5e99dc0c36 100644
--- a/framework_crates/bones_scripting/src/lua/asset.rs
+++ b/framework_crates/bones_scripting/src/lua/asset.rs
@@ -131,21 +131,6 @@ fn session_metatable(ctx: Context) -> Table {
         )
         .unwrap();
 
-    let add_startup_system_callback = ctx.registry().stash(
-        &ctx,
-        Callback::from_fn(&ctx, move |ctx, _fuel, mut stack| {
-            let (this, closure): (UserData, Closure) = stack.consume(ctx)?;
-            let this = this.downcast_static::<LuaPluginSystemsCell>()?;
-
-            let mut systems = this.borrow_mut();
-            systems
-                .as_loaded_mut()
-                .startup
-                .push((false, ctx.registry().stash(&ctx, closure)));
-
-            Ok(CallbackReturn::Return)
-        }),
-    );
     let add_system_to_stage_callback = ctx.registry().stash(
         &ctx,
         Callback::from_fn(&ctx, move |ctx, _fuel, mut stack| {
@@ -176,9 +161,6 @@ fn session_metatable(ctx: Context) -> Table {
                         stack
                             .push_front(ctx.registry().fetch(&add_system_to_stage_callback).into());
                     }
-                    b"add_startup_system" => {
-                        stack.push_front(ctx.registry().fetch(&add_startup_system_callback).into());
-                    }
                     _ => (),
                 }
 
@@ -234,8 +216,6 @@ pub type SystemStageId = Ulid;
 /// The systems that have been registered by a lua plugin.
 #[derive(Default)]
 pub struct LuaPluginSystems {
-    /// Startup systems. The bool indicates whether the system has been run yet.
-    pub startup: Vec<(bool, StashedClosure)>,
     /// Systems that run in the core stages.
     pub core_stages: Vec<(CoreStage, StashedClosure)>,
 }
diff --git a/framework_crates/bones_scripting/src/lua/bindings.rs b/framework_crates/bones_scripting/src/lua/bindings.rs
index 9a4a5c9d93..a3bad98f03 100644
--- a/framework_crates/bones_scripting/src/lua/bindings.rs
+++ b/framework_crates/bones_scripting/src/lua/bindings.rs
@@ -49,6 +49,7 @@ pub fn env(ctx: Context) -> Table {
     // Set the `CoreStage` enum global
     let core_stage_table = Table::new(&ctx);
     for (name, stage) in [
+        ("Startup", CoreStage::Startup),
         ("First", CoreStage::First),
         ("PreUpdate", CoreStage::PreUpdate),
         ("Update", CoreStage::Update),
diff --git a/framework_crates/bones_scripting/src/lua/bindings/schema.rs b/framework_crates/bones_scripting/src/lua/bindings/schema.rs
index 91ddc718af..c25d9fc7db 100644
--- a/framework_crates/bones_scripting/src/lua/bindings/schema.rs
+++ b/framework_crates/bones_scripting/src/lua/bindings/schema.rs
@@ -28,7 +28,14 @@ pub fn schema_fn(ctx: Context) -> Callback {
             schema.set_metatable(&ctx, Some(schema_metatable));
             stack.push_front(schema.into());
         } else {
+            #[cfg(not(debug_assertions))] // script info only, not a developer
             return Err(anyhow::format_err!("Schema not found: {schema_name}").into());
+
+            #[cfg(debug_assertions)] // add note about registry, probably a developer
+            return Err(anyhow::format_err!(
+                "Schema not found: {schema_name}, you may need to register the schema"
+            )
+            .into());
         }
 
         Ok(CallbackReturn::Return)

From ab9dcc3996ea8382c63a2da8a396f654ac5d8f97 Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Mon, 11 May 2026 08:41:48 -0500
Subject: [PATCH 03/36] chore: remove mutable world borrows from
 `World::init_resource`

---
 framework_crates/bones_ecs/src/world.rs                | 4 ++--
 framework_crates/bones_framework/tests/system_param.rs | 2 +-
 framework_crates/bones_lib/src/lib.rs                  | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/framework_crates/bones_ecs/src/world.rs b/framework_crates/bones_ecs/src/world.rs
index 867d3686d4..bad906b94b 100644
--- a/framework_crates/bones_ecs/src/world.rs
+++ b/framework_crates/bones_ecs/src/world.rs
@@ -130,7 +130,7 @@ impl World {
     }
 
     /// Initialize a resource of type `T` by inserting it's default value.
-    pub fn init_resource<R: HasSchema + FromWorld>(&mut self) -> RefMut<'_, R> {
+    pub fn init_resource<R: HasSchema + FromWorld>(&self) -> RefMut<'_, R> {
         if unlikely(!self.resources.contains::<R>()) {
             let value = R::from_world(self);
             self.resources.insert(value);
@@ -394,7 +394,7 @@ mod tests {
 
     #[test]
     fn init_resource_does_not_overwrite() {
-        let mut w = World::default();
+        let w = World::default();
         w.insert_resource(TestResource(0));
         w.init_resource::<TestFromWorld>();
         w.insert_resource(TestResource(1));
diff --git a/framework_crates/bones_framework/tests/system_param.rs b/framework_crates/bones_framework/tests/system_param.rs
index f61ce6784b..e2f4be8462 100644
--- a/framework_crates/bones_framework/tests/system_param.rs
+++ b/framework_crates/bones_framework/tests/system_param.rs
@@ -9,7 +9,7 @@ use futures_lite::{
 };
 
 fn create_world() -> World {
-    let mut world = World::default();
+    let world = World::default();
 
     let core_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
         .join("tests")
diff --git a/framework_crates/bones_lib/src/lib.rs b/framework_crates/bones_lib/src/lib.rs
index 407ce6cc0f..c23ae739ca 100644
--- a/framework_crates/bones_lib/src/lib.rs
+++ b/framework_crates/bones_lib/src/lib.rs
@@ -205,7 +205,7 @@ impl SessionBuilder {
     pub fn finish_and_add(mut self, sessions: &mut Sessions) -> &mut Session {
         let mut session = Session {
             world: {
-                let mut w = World::default();
+                let w = World::default();
                 w.init_resource::<Time>();
                 w
             },

From f41606e2ddec78cb9dc4ac2e5441ec202c9c6754 Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Mon, 11 May 2026 08:46:45 -0500
Subject: [PATCH 04/36] refactor: move single success systems management out of
 SystemStages and into wrapper system implementation on SessionBuilder.

---
 framework_crates/bones_ecs/src/stage.rs | 75 -------------------------
 framework_crates/bones_lib/src/lib.rs   | 57 ++++++++++++++++++-
 2 files changed, 56 insertions(+), 76 deletions(-)

diff --git a/framework_crates/bones_ecs/src/stage.rs b/framework_crates/bones_ecs/src/stage.rs
index 2e13cb92c1..63e709b26d 100644
--- a/framework_crates/bones_ecs/src/stage.rs
+++ b/framework_crates/bones_ecs/src/stage.rs
@@ -18,9 +18,6 @@ pub struct SystemStagesBuilder {
 
     /// Resources installed during session plugin installs. Copied to world as first step on startup of stages' execution.
     startup_resources: UntypedResourceSet,
-
-    /// Systems that are continously run until they succeed(return Some). These run before all stages. Uses Option to allow for easy usage of `?`.
-    single_success_systems: Vec<StaticSystem<(), Option<()>>>,
 }
 
 impl Default for SystemStagesBuilder {
@@ -42,7 +39,6 @@ impl SystemStagesBuilder {
                 Box::new(SimpleSystemStage::new(CoreStage::Last)),
             ],
             startup_resources: default(),
-            single_success_systems: Vec::new(),
         }
     }
 
@@ -51,7 +47,6 @@ impl SystemStagesBuilder {
         SystemStages {
             stages: self.stages,
             startup_resources: self.startup_resources,
-            single_success_systems: self.single_success_systems,
         }
     }
 
@@ -60,7 +55,6 @@ impl SystemStagesBuilder {
         Self {
             stages: stages.stages,
             startup_resources: stages.startup_resources,
-            single_success_systems: stages.single_success_systems,
         }
     }
 
@@ -76,15 +70,6 @@ impl SystemStagesBuilder {
         self
     }
 
-    /// Add a system that will run each frame until it succeeds (returns Some). Runs before all stages. Uses Option to allow for easy usage of `?`.
-    pub fn add_single_success_system<Args, S>(&mut self, system: S) -> &mut Self
-    where
-        S: IntoSystem<Args, (), Option<()>, Sys = StaticSystem<(), Option<()>>>,
-    {
-        self.single_success_systems.push(system.system());
-        self
-    }
-
     /// Add a [`System`] to the stage with the given label.
     pub fn add_system_to_stage<Args, S>(&mut self, label: impl StageLabel, system: S) -> &mut Self
     where
@@ -170,9 +155,6 @@ pub struct SystemStages {
 
     /// Resources installed during session plugin installs. Copied to world as first step on startup of stages' execution.
     startup_resources: UntypedResourceSet,
-
-    /// Systems that are continously run until they succeed(return Some). These run before all stages. Uses Option to allow for easy usage of `?`.
-    single_success_systems: Vec<StaticSystem<(), Option<()>>>,
 }
 
 impl std::fmt::Debug for SystemStages {
@@ -202,15 +184,6 @@ impl SystemStages {
         // If we haven't setup resources yet, do so
         self.handle_startup_resources(world);
 
-        // Run single success systems
-        for (index, system) in self.single_success_systems.iter_mut().enumerate() {
-            let should_run = !Self::has_single_success_system_succeeded(index, world);
-
-            if should_run && system.run(world, ()).is_some() {
-                Self::mark_single_success_system_succeeded(index, world);
-            }
-        }
-
         // Run each stage
         for stage in &mut self.stages {
             // Set the current stage resource
@@ -242,28 +215,6 @@ impl SystemStages {
         }
     }
 
-    /// Check if single success system is marked as succeeded in [`SingleSuccessSystems`] [`Resource`].
-    fn has_single_success_system_succeeded(system_index: usize, world: &World) -> bool {
-        if let Some(system_success) = world.get_resource::<SingleSuccessSystems>() {
-            return system_success.has_system_succeeded(system_index);
-        }
-
-        false
-    }
-
-    /// Mark a single success system as succeeded in [`SingleSuccessSystems`] [`Resource`].
-    fn mark_single_success_system_succeeded(system_index: usize, world: &mut World) {
-        if let Some(mut system_succes) = world.get_resource_mut::<SingleSuccessSystems>() {
-            system_succes.set_system_completed(system_index);
-            return;
-        }
-
-        // Resource does not exist - must initialize it
-        world
-            .init_resource::<SingleSuccessSystems>()
-            .set_system_completed(system_index);
-    }
-
     /// Insert the startup resources that [`SystemStages`] and session were built with into [`World`].
     ///
     /// This will update [`SessionStarted`] resource to flag that startup resources are inserted.
@@ -521,29 +472,3 @@ impl<'a> SystemParam for Commands<'a> {
 /// If resource is not present, assumed to have not started (and will be initialized upon next stage execution).
 #[derive(Copy, Clone, HasSchema, Default)]
 pub struct StartupResourcesInserted;
-
-/// Resource tracking which of single success systems in `Session`'s [`SystemStages`] have completed.
-/// Success is tracked to
-#[derive(HasSchema, Clone, Default)]
-pub struct SingleSuccessSystems {
-    /// Set of indices of [`SystemStages`]'s single success systems that have succeeded.
-    pub systems_succeeded: HashSet<usize>,
-}
-
-impl SingleSuccessSystems {
-    /// Reset single success systems completion status. so they run again until success.
-    #[allow(dead_code)]
-    pub fn reset(&mut self) {
-        self.systems_succeeded.clear();
-    }
-
-    /// Check if system has completed
-    pub fn has_system_succeeded(&self, index: usize) -> bool {
-        self.systems_succeeded.contains(&index)
-    }
-
-    /// Mark system as completed.
-    pub fn set_system_completed(&mut self, index: usize) {
-        self.systems_succeeded.insert(index);
-    }
-}
diff --git a/framework_crates/bones_lib/src/lib.rs b/framework_crates/bones_lib/src/lib.rs
index c23ae739ca..bc2c51fe42 100644
--- a/framework_crates/bones_lib/src/lib.rs
+++ b/framework_crates/bones_lib/src/lib.rs
@@ -154,7 +154,9 @@ impl SessionBuilder {
     where
         S: IntoSystem<Args, (), Option<()>, Sys = StaticSystem<(), Option<()>>>,
     {
-        self.stages.add_single_success_system(system.system());
+        let id = self.init_resource::<SingleSuccessSystems>().next_id();
+        self.stages
+            .add_system_to_stage(First, single_success_system(id, system));
         self
     }
 
@@ -241,6 +243,59 @@ impl Drop for FinishGuard {
     }
 }
 
+/// Wrapper system for single success systems. Takes a system, and an `usize` id
+/// that is used to index whether or not the system has succeeded from the
+/// [`SingleSuccessSystems`] resource.
+fn single_success_system<Args, S>(id: usize, system: S) -> StaticSystem<(), ()>
+where
+    S: IntoSystem<Args, (), Option<()>, Sys = StaticSystem<(), Option<()>>>,
+{
+    let mut system = system.system();
+    (move |world: &World| {
+        let succeeded = world
+            .init_resource::<SingleSuccessSystems>()
+            .has_system_succeeded(id);
+        if !succeeded && system.run(world, ()).is_some() {
+            world
+                .init_resource::<SingleSuccessSystems>()
+                .set_system_completed(id);
+        }
+    })
+    .system()
+}
+
+/// Resource tracking which of single success systems have completed.
+#[derive(HasSchema, Clone, Default)]
+pub struct SingleSuccessSystems {
+    /// Used for id creation as single success systems are added to the session.
+    last_id: usize,
+    /// Set of indices of single success systems that have succeeded.
+    pub systems_succeeded: HashSet<usize>,
+}
+
+impl SingleSuccessSystems {
+    /// Returns the next `usize` for the next single success system to use.
+    pub fn next_id(&mut self) -> usize {
+        self.last_id += 1;
+        self.last_id
+    }
+    /// Reset single success systems completion status. so they run again until success.
+    #[allow(dead_code)]
+    pub fn reset(&mut self) {
+        self.systems_succeeded.clear();
+    }
+
+    /// Check if system has completed
+    pub fn has_system_succeeded(&self, index: usize) -> bool {
+        self.systems_succeeded.contains(&index)
+    }
+
+    /// Mark system as completed.
+    pub fn set_system_completed(&mut self, index: usize) {
+        self.systems_succeeded.insert(index);
+    }
+}
+
 /// A bones game. This includes all of the game worlds, and systems.
 ///
 /// [`Session`] is not allowed to be constructed directly.

From a4ac50a22d0000ebe8e6e741f97902904baf5693 Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Tue, 12 May 2026 09:21:49 -0500
Subject: [PATCH 05/36] refactor!: move startup resource management out of
 SystemStages and into SessionBuilder.

Removes the need for the SystemStages in World reset implementations.
---
 framework_crates/bones_ecs/src/stage.rs       | 73 +------------------
 .../bones_framework/src/networking.rs         |  2 +-
 framework_crates/bones_lib/src/lib.rs         | 33 +++++++--
 framework_crates/bones_lib/src/reset.rs       | 16 ++--
 4 files changed, 38 insertions(+), 86 deletions(-)

diff --git a/framework_crates/bones_ecs/src/stage.rs b/framework_crates/bones_ecs/src/stage.rs
index 63e709b26d..24b8be61eb 100644
--- a/framework_crates/bones_ecs/src/stage.rs
+++ b/framework_crates/bones_ecs/src/stage.rs
@@ -8,6 +8,7 @@ use crate::prelude::*;
 /// that specifies the unique ID of the stage that being run.
 ///
 /// If the stage is `Ulid(0)`, the default ID, then that means the startup stage is being run.
+// TODO: remove this resource if unused.
 #[derive(Deref, DerefMut, Clone, Copy, HasSchema, Default)]
 pub struct CurrentSystemStage(pub Ulid);
 
@@ -15,9 +16,6 @@ pub struct CurrentSystemStage(pub Ulid);
 pub struct SystemStagesBuilder {
     /// The stages in the collection, in the order that they will be run.
     stages: Vec<Box<dyn SystemStage>>,
-
-    /// Resources installed during session plugin installs. Copied to world as first step on startup of stages' execution.
-    startup_resources: UntypedResourceSet,
 }
 
 impl Default for SystemStagesBuilder {
@@ -38,7 +36,6 @@ impl SystemStagesBuilder {
                 Box::new(SimpleSystemStage::new(CoreStage::PostUpdate)),
                 Box::new(SimpleSystemStage::new(CoreStage::Last)),
             ],
-            startup_resources: default(),
         }
     }
 
@@ -46,7 +43,6 @@ impl SystemStagesBuilder {
     pub fn finish(self) -> SystemStages {
         SystemStages {
             stages: self.stages,
-            startup_resources: self.startup_resources,
         }
     }
 
@@ -54,7 +50,6 @@ impl SystemStagesBuilder {
     pub fn from_stages(stages: SystemStages) -> Self {
         Self {
             stages: stages.stages,
-            startup_resources: stages.startup_resources,
         }
     }
 
@@ -127,34 +122,12 @@ impl SystemStagesBuilder {
 
         self
     }
-
-    /// Insert a startup resource. On stage / session startup (first step), will be inserted into [`World`].
-    ///
-    /// If already exists, will be overwritten.
-    pub fn insert_startup_resource<T: HasSchema>(&mut self, resource: T) {
-        self.startup_resources.insert_resource(resource);
-    }
-
-    /// Init startup resource with default, and return mutable ref for modification.
-    /// If already exists, returns mutable ref to existing resource.
-    pub fn init_startup_resource<T: HasSchema + Default>(&mut self) -> RefMut<'_, T> {
-        self.startup_resources.init_resource::<T>()
-    }
-
-    /// Get mutable reference to startup resource if found.
-    #[track_caller]
-    pub fn startup_resource_mut<T: HasSchema>(&self) -> Option<RefMut<'_, T>> {
-        self.startup_resources.resource_mut()
-    }
 }
 
 /// An ordered collection of [`SystemStage`]s.
 pub struct SystemStages {
     /// The stages in the collection, in the order that they will be run.
     stages: Vec<Box<dyn SystemStage>>,
-
-    /// Resources installed during session plugin installs. Copied to world as first step on startup of stages' execution.
-    startup_resources: UntypedResourceSet,
 }
 
 impl std::fmt::Debug for SystemStages {
@@ -181,9 +154,6 @@ impl SystemStages {
 
     /// Execute the systems on the given `world`.
     pub fn run(&mut self, world: &mut World) {
-        // If we haven't setup resources yet, do so
-        self.handle_startup_resources(world);
-
         // Run each stage
         for stage in &mut self.stages {
             // Set the current stage resource
@@ -199,40 +169,6 @@ impl SystemStages {
         // Remove the current system stage resource
         world.resources.remove::<CurrentSystemStage>();
     }
-
-    /// If [`StartupResourcesInserted`] resource has not yet been inserted, will do so.
-    ///
-    /// # Panics
-    ///
-    /// May panic if resources are borrowed, should not borrow resources when calling.
-    pub fn handle_startup_resources(&mut self, world: &mut World) {
-        let inserted = world.get_resource::<StartupResourcesInserted>().is_some();
-
-        if !inserted {
-            self.insert_startup_resources(world);
-
-            world.insert_resource(StartupResourcesInserted);
-        }
-    }
-
-    /// Insert the startup resources that [`SystemStages`] and session were built with into [`World`].
-    ///
-    /// This will update [`SessionStarted`] resource to flag that startup resources are inserted.
-    fn insert_startup_resources(&self, world: &mut World) {
-        for resource in self.startup_resources.resources().iter() {
-            // Deep copy startup resource and insert into world.
-            let resource_copy = resource.clone_data().unwrap();
-            let resource_cell = world.resources.untyped().get_cell(resource.schema());
-            let prev_val = resource_cell.insert(resource_copy).unwrap();
-
-            // Warn on already existing resource
-            if prev_val.is_some() {
-                let schema_name = resource.schema().full_name;
-                tracing::warn!("SystemStages` attempted to inserted resource {schema_name} on startup that already exists in world - startup resource not inserted.
-                    When building new session, startup resources should be initialized on `SessionBuilder`.");
-            }
-        }
-    }
 }
 
 /// Trait for system stages. A stage is a
@@ -465,10 +401,3 @@ impl<'a> SystemParam for Commands<'a> {
         Commands(state.borrow_mut().unwrap())
     }
 }
-
-/// Have startup resources beeen inserted into [`World`]?
-///
-/// If field is set to false, that operation needs to be handled on next stage run.
-/// If resource is not present, assumed to have not started (and will be initialized upon next stage execution).
-#[derive(Copy, Clone, HasSchema, Default)]
-pub struct StartupResourcesInserted;
diff --git a/framework_crates/bones_framework/src/networking.rs b/framework_crates/bones_framework/src/networking.rs
index b7953687b1..742333ebf3 100644
--- a/framework_crates/bones_framework/src/networking.rs
+++ b/framework_crates/bones_framework/src/networking.rs
@@ -876,7 +876,7 @@ where
                                             }
                                         }
 
-                                        world.handle_world_reset(stages);
+                                        world.reset_internals();
                                     }
                                 }
                             }
diff --git a/framework_crates/bones_lib/src/lib.rs b/framework_crates/bones_lib/src/lib.rs
index bc2c51fe42..41bbc66748 100644
--- a/framework_crates/bones_lib/src/lib.rs
+++ b/framework_crates/bones_lib/src/lib.rs
@@ -13,6 +13,7 @@ pub mod prelude {
     pub use crate::{
         ecs::prelude::*, instant::Instant, reset::*, time::*, Game, GamePlugin, Session,
         SessionBuilder, SessionCommand, SessionOptions, SessionPlugin, SessionRunner, Sessions,
+        StartupResources,
     };
     pub use ustr::{ustr, Ustr, UstrMap, UstrSet};
 }
@@ -33,6 +34,10 @@ pub struct SessionBuilder {
     pub name: Ustr,
     /// System stage builder
     pub stages: SystemStagesBuilder,
+    /// Resources to be inserted into the world when finished building. Inserted
+    /// collectively into the world as the [`StartupResources`] resource to be
+    /// used by [`ResetWorld`] functionality.
+    pub startup_resources: UntypedResourceSet,
     /// Whether or not this session should have it's systems run.
     pub active: bool,
     /// Whether or not this session should be rendered.
@@ -62,6 +67,7 @@ impl SessionBuilder {
         Self {
             name,
             stages: default(),
+            startup_resources: default(),
             active: true,
             visible: true,
             priority: 0,
@@ -83,6 +89,12 @@ impl SessionBuilder {
         Self {
             name,
             stages: SystemStagesBuilder::from_stages(session.stages),
+            startup_resources: session
+                .world
+                .resources
+                .remove::<StartupResources>()
+                .unwrap_or_default()
+                .0,
             active: session.active,
             visible: session.visible,
             priority: session.priority,
@@ -119,7 +131,7 @@ impl SessionBuilder {
     /// Note: The resource is not actually initialized in World until first step of [`SystemStages`].
     /// To mutate or inspect a resource inserted by another [`SessionPlugin`] during session build, use [`SessionBuilder::resource_mut`].
     pub fn insert_resource<T: HasSchema>(&mut self, resource: T) -> &mut Self {
-        self.stages.insert_startup_resource(resource);
+        self.startup_resources.insert_resource(resource);
         self
     }
 
@@ -128,12 +140,12 @@ impl SessionBuilder {
     /// Note: The resource is not actually initialized in World until first step of [`SystemStages`].
     /// To mutate or inspect a resource inserted by another [`SessionPlugin`] during session build, use [`SessionBuilder::resource_mut`].
     pub fn init_resource<T: HasSchema + Default>(&mut self) -> RefMut<'_, T> {
-        self.stages.init_startup_resource::<T>()
+        self.startup_resources.init_resource::<T>()
     }
 
     /// Get mutable reference to a resource if it exists.
     pub fn resource_mut<T: HasSchema>(&self) -> Option<RefMut<'_, T>> {
-        self.stages.startup_resource_mut::<T>()
+        self.startup_resources.resource_mut::<T>()
     }
 
     /// Add a system to the [`CoreStage::Startup`] stage which specially runs
@@ -222,13 +234,20 @@ impl SessionBuilder {
         self.finish_guard.finished = true;
 
         // Insert startup resources so if other sessions look for them, they are present.
-        // Startup systems are deferred until first step of stages.
-        session.stages.handle_startup_resources(&mut session.world);
+        self.startup_resources
+            .insert_on_world(&mut session.world, true);
+        session
+            .world
+            .insert_resource(StartupResources(self.startup_resources));
 
         sessions.add(self.name, session)
     }
 }
 
+/// Resource used for initializing resources on reset with [`ResetWorld`].
+#[derive(HasSchema, Clone, Default, Deref, DerefMut)]
+pub struct StartupResources(pub UntypedResourceSet);
+
 /// Guard for [`SessionBuilder` ensuring we warn if it goes out of scope without being finished and added to [`Sessions`].
 struct FinishGuard {
     pub finished: bool,
@@ -396,7 +415,7 @@ pub trait SessionRunner: Sync + Send + 'static {
     ///
     ///     // Not required for runner - but calling this allows [`ResetWorld`] resource to
     ///     // reset world state from gameplay.
-    ///     world.handle_world_reset(stages);
+    ///     world.handle_world_reset();
     ///
     /// }
     /// fn restart_session(&mut self) {}
@@ -424,7 +443,7 @@ impl SessionRunner for DefaultSessionRunner {
         stages.run(world);
 
         // Checks if reset of world has been triggered by [`ResetWorld`] and handles a reset.
-        world.handle_world_reset(stages);
+        world.handle_world_reset();
     }
 
     // This is a no-op as no state, but implemented this way in case that changes later.
diff --git a/framework_crates/bones_lib/src/reset.rs b/framework_crates/bones_lib/src/reset.rs
index e4cf1ed831..f50835b19c 100644
--- a/framework_crates/bones_lib/src/reset.rs
+++ b/framework_crates/bones_lib/src/reset.rs
@@ -44,7 +44,7 @@ pub trait WorldExt {
     ///
     /// `stages` is required, so that after reset, will immediatelly run startup tasks, instead of waiting until next step of [`SystemStages`].
     /// This avoids edge cases where other sessions may read expected resources from this session before its next step.
-    fn handle_world_reset(&mut self, stages: &mut SystemStages);
+    fn handle_world_reset(&mut self);
 
     /// Check if reset has been triggered by [`ResetWorld`] resource. If [`SessionRunner`] needs to do anything special
     /// for a world reset (preserve managed resources, etc) - can check this before calling `handle_world_reset` to see
@@ -58,13 +58,13 @@ pub trait WorldExt {
     ///
     /// Waring: Calling this function on World in a [`Session`] using network session runner is likely to introduce non-determinism.
     /// It is strongly recommended to use the [`ResetWorld`] Resource to trigger this in manner compatible with net rollback.
-    fn reset_internals(&mut self, stages: &mut SystemStages);
+    fn reset_internals(&mut self);
 }
 
 impl WorldExt for World {
-    fn handle_world_reset(&mut self, stages: &mut SystemStages) {
+    fn handle_world_reset(&mut self) {
         if self.reset_triggered() {
-            self.reset_internals(stages);
+            self.reset_internals();
         }
     }
 
@@ -72,7 +72,7 @@ impl WorldExt for World {
         self.get_resource::<ResetWorld>().is_some_and(|r| r.reset)
     }
 
-    fn reset_internals(&mut self, stages: &mut SystemStages) {
+    fn reset_internals(&mut self) {
         // Copy resources to be inserted after the reset.
         let post_reset_resources = self
             .get_resource::<ResetWorld>()
@@ -84,6 +84,7 @@ impl WorldExt for World {
         // save copy of special resources that should always remain in session / managed by bones
         let time = self.get_resource::<Time>().map(|t| *t);
         let session_opts = self.get_resource::<SessionOptions>().map(|x| *x);
+        let startup_resources = self.get_resource::<StartupResources>().map(|r| r.0.clone());
 
         // Remove any owned resources (preserves shared resources)
         // This allows world resources to be reset inside session run safely, as shared resources are only injected
@@ -103,7 +104,10 @@ impl WorldExt for World {
 
         // Insert startup resources, but do not yet run startup systems. (We do this after applying additional preserved "reset resources", as
         // startup systems may want to access these).
-        stages.handle_startup_resources(self);
+        if let Some(resources) = startup_resources {
+            let remove_empty = true;
+            resources.insert_on_world(self, remove_empty);
+        }
 
         // Apply any reset resources to world, overwriting startup resources.
         if let Some(resources) = post_reset_resources {

From 95f5ae79f92cc56cc3fea598c54e792e45dc0753 Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Tue, 12 May 2026 09:40:42 -0500
Subject: [PATCH 06/36] chore: remove deprecated comment

---
 framework_crates/bones_ecs/src/stage.rs | 2 --
 1 file changed, 2 deletions(-)

diff --git a/framework_crates/bones_ecs/src/stage.rs b/framework_crates/bones_ecs/src/stage.rs
index 24b8be61eb..dc8af78fec 100644
--- a/framework_crates/bones_ecs/src/stage.rs
+++ b/framework_crates/bones_ecs/src/stage.rs
@@ -6,8 +6,6 @@ use crate::prelude::*;
 
 /// Resource that is automatically added to the world while a system stage is being run
 /// that specifies the unique ID of the stage that being run.
-///
-/// If the stage is `Ulid(0)`, the default ID, then that means the startup stage is being run.
 // TODO: remove this resource if unused.
 #[derive(Deref, DerefMut, Clone, Copy, HasSchema, Default)]
 pub struct CurrentSystemStage(pub Ulid);

From de7468a91e3fcf63c378366ef7a415d22e067d05 Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Tue, 12 May 2026 20:05:03 -0500
Subject: [PATCH 07/36] chore: remove uneeded copies & clones. Remove implied
 and/or distracting comment.

---
 framework_crates/bones_lib/src/reset.rs | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/framework_crates/bones_lib/src/reset.rs b/framework_crates/bones_lib/src/reset.rs
index f50835b19c..cc9bab8ef1 100644
--- a/framework_crates/bones_lib/src/reset.rs
+++ b/framework_crates/bones_lib/src/reset.rs
@@ -73,18 +73,18 @@ impl WorldExt for World {
     }
 
     fn reset_internals(&mut self) {
-        // Copy resources to be inserted after the reset.
-        let post_reset_resources = self
-            .get_resource::<ResetWorld>()
-            .map(|x| x.reset_resources.clone());
-
         // Clear all component stores
         self.components = ComponentStores::default();
 
-        // save copy of special resources that should always remain in session / managed by bones
-        let time = self.get_resource::<Time>().map(|t| *t);
-        let session_opts = self.get_resource::<SessionOptions>().map(|x| *x);
-        let startup_resources = self.get_resource::<StartupResources>().map(|r| r.0.clone());
+        // move out special resources that should always remain in session / managed by bones
+        let time = self.resources.remove::<Time>();
+        let session_opts = self.resources.remove::<SessionOptions>();
+        let startup_resources = self.resources.remove::<StartupResources>();
+
+        let post_reset_resources = self
+            .resources
+            .remove::<ResetWorld>()
+            .map(|r| r.reset_resources);
 
         // Remove any owned resources (preserves shared resources)
         // This allows world resources to be reset inside session run safely, as shared resources are only injected
@@ -102,8 +102,7 @@ impl WorldExt for World {
             self.insert_resource(session_opts);
         }
 
-        // Insert startup resources, but do not yet run startup systems. (We do this after applying additional preserved "reset resources", as
-        // startup systems may want to access these).
+        // Insert startup resources.
         if let Some(resources) = startup_resources {
             let remove_empty = true;
             resources.insert_on_world(self, remove_empty);

From 4ee0bfb6bda256b9ecca5f2907a779f5696b568b Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Wed, 13 May 2026 10:37:50 -0500
Subject: [PATCH 08/36] chore: remove mutable reference requirement on
 `clear_owned_resources` & add that method `World` level.

---
 framework_crates/bones_ecs/src/resources.rs | 10 +++++-----
 framework_crates/bones_ecs/src/world.rs     |  5 +++++
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/framework_crates/bones_ecs/src/resources.rs b/framework_crates/bones_ecs/src/resources.rs
index 175f9030b0..64e784c3c3 100644
--- a/framework_crates/bones_ecs/src/resources.rs
+++ b/framework_crates/bones_ecs/src/resources.rs
@@ -202,8 +202,8 @@ impl UntypedResources {
     }
 
     /// Removes all resourcse that are not shared resources.
-    pub fn clear_owned_resources(&mut self) {
-        for (schema_id, resource_cell) in self.resources.iter_mut() {
+    pub fn clear_owned_resources(&self) {
+        for (schema_id, resource_cell) in self.resources.read_only_view().iter() {
             let is_shared = self.shared_resources.contains_key(schema_id);
             if !is_shared {
                 resource_cell.remove();
@@ -297,8 +297,8 @@ impl Resources {
     }
 
     /// Removes all resources that are not shared. Shared resources are preserved.
-    pub fn clear_owned_resources(&mut self) {
-        self.untyped.clear_owned_resources();
+    pub fn clear_owned_resources(&self) {
+        self.untyped().clear_owned_resources();
     }
 }
 
@@ -604,7 +604,7 @@ mod test {
 
     #[test]
     fn resources_clear_owned_values() {
-        let mut r = Resources::new();
+        let r = Resources::new();
 
         // insert A as non-shared resource
         r.insert(A(String::from("foo")));
diff --git a/framework_crates/bones_ecs/src/world.rs b/framework_crates/bones_ecs/src/world.rs
index bad906b94b..7c83ca21cf 100644
--- a/framework_crates/bones_ecs/src/world.rs
+++ b/framework_crates/bones_ecs/src/world.rs
@@ -183,6 +183,11 @@ impl World {
         self.resources.get_mut()
     }
 
+    /// Removes all resources that are not shared. Shared resources are preserved.
+    pub fn clear_owned_resources(&self) {
+        self.resources.clear_owned_resources();
+    }
+
     /// Borrow a component store from the world.
     /// # Panics
     /// Panics if the component store does not exist in the world.

From 3af9bb5667bac59fec1b39fa3491c349160efa66 Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Wed, 13 May 2026 12:38:48 -0500
Subject: [PATCH 09/36] feat: add retain resources methods on UntypedResources
 & World

---
 framework_crates/bones_ecs/src/resources.rs | 31 +++++++++++++++++++++
 framework_crates/bones_ecs/src/world.rs     | 20 +++++++++++++
 2 files changed, 51 insertions(+)

diff --git a/framework_crates/bones_ecs/src/resources.rs b/framework_crates/bones_ecs/src/resources.rs
index 64e784c3c3..a775160408 100644
--- a/framework_crates/bones_ecs/src/resources.rs
+++ b/framework_crates/bones_ecs/src/resources.rs
@@ -201,6 +201,37 @@ impl UntypedResources {
         )
     }
 
+    /// Iterates through owned and shared resource cells removing them if the predicate returns `false`.
+    ///
+    /// See also: [`Self::retain_owned_resources`].
+    pub fn retain_resources<F>(&self, mut predicate: F)
+    where
+        F: FnMut(SchemaId) -> bool,
+    {
+        for (schema_id, resource_cell) in self.resources.read_only_view().iter() {
+            let is_retained = predicate(*schema_id);
+            if !is_retained {
+                resource_cell.remove();
+            }
+        }
+    }
+
+    /// Iterates through resource cells removing them if the predicate returns `false`.
+    ///
+    /// Doesn't include shared resources. See also: [`Self::retain_resources`].
+    pub fn retain_owned_resources<F>(&self, mut predicate: F)
+    where
+        F: FnMut(SchemaId) -> bool,
+    {
+        for (schema_id, resource_cell) in self.resources.read_only_view().iter() {
+            let is_shared = self.shared_resources.contains_key(schema_id);
+            let is_retained = predicate(*schema_id);
+            if !is_shared && !is_retained {
+                resource_cell.remove();
+            }
+        }
+    }
+
     /// Removes all resourcse that are not shared resources.
     pub fn clear_owned_resources(&self) {
         for (schema_id, resource_cell) in self.resources.read_only_view().iter() {
diff --git a/framework_crates/bones_ecs/src/world.rs b/framework_crates/bones_ecs/src/world.rs
index 7c83ca21cf..67f8a54337 100644
--- a/framework_crates/bones_ecs/src/world.rs
+++ b/framework_crates/bones_ecs/src/world.rs
@@ -188,6 +188,26 @@ impl World {
         self.resources.clear_owned_resources();
     }
 
+    /// Iterates through owned and shared resource cells removing them if the predicate returns `false`.
+    ///
+    /// See also: [`Self::retain_owned_resources`].
+    pub fn retain_resources<F>(&self, predicate: F)
+    where
+        F: FnMut(SchemaId) -> bool,
+    {
+        self.resources.untyped().retain_resources(predicate);
+    }
+
+    /// Iterates through resource cells removing them if the predicate returns `false`.
+    ///
+    /// Doesn't include shared resources. See also: [`Self::retain_resources`].
+    pub fn retain_owned_resources<F>(&self, predicate: F)
+    where
+        F: FnMut(SchemaId) -> bool,
+    {
+        self.resources.untyped().retain_owned_resources(predicate);
+    }
+
     /// Borrow a component store from the world.
     /// # Panics
     /// Panics if the component store does not exist in the world.

From eb5e28c3200f75969d22a4f5474a9db69bbb4ca9 Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Wed, 13 May 2026 15:22:05 -0500
Subject: [PATCH 10/36] refactor!: put SingleSuccessSystems resource in prelude
 & update single success systems to use Ulids & deprecate
 `add_single_success_system` in favor of stable usage for now

---
 framework_crates/bones_lib/src/lib.rs | 59 ++++++++++++++-------------
 1 file changed, 30 insertions(+), 29 deletions(-)

diff --git a/framework_crates/bones_lib/src/lib.rs b/framework_crates/bones_lib/src/lib.rs
index 41bbc66748..6211ce53a4 100644
--- a/framework_crates/bones_lib/src/lib.rs
+++ b/framework_crates/bones_lib/src/lib.rs
@@ -11,9 +11,9 @@ pub use bones_ecs as ecs;
 /// Bones lib prelude
 pub mod prelude {
     pub use crate::{
-        ecs::prelude::*, instant::Instant, reset::*, time::*, Game, GamePlugin, Session,
-        SessionBuilder, SessionCommand, SessionOptions, SessionPlugin, SessionRunner, Sessions,
-        StartupResources,
+        ecs::prelude::*, instant::Instant, reset::*, single_success_system, time::*, Game,
+        GamePlugin, Session, SessionBuilder, SessionCommand, SessionOptions, SessionPlugin,
+        SessionRunner, Sessions, SingleSuccessSystems, StartupResources,
     };
     pub use ustr::{ustr, Ustr, UstrMap, UstrSet};
 }
@@ -161,14 +161,18 @@ impl SessionBuilder {
         self
     }
 
-    /// Add a system that will run each frame until it succeeds (returns Some). Runs before all stages. Uses Option to allow for easy usage of `?`.
+    /// Convenience method. Adds a system that will run each frame until it succeeds (returns Some).
+    /// Uses Option to allow for easy usage of `?`. System is added to
+    /// [`CoreStage::First`].
+    ///
+    /// See also the wrapper function used inside [`single_success_system`].
+    #[deprecated = "use `.add_system_to_stage(First, single_success_system(Ulid::new(), your_system)"]
     pub fn add_single_success_system<Args, S>(&mut self, system: S) -> &mut Self
     where
         S: IntoSystem<Args, (), Option<()>, Sys = StaticSystem<(), Option<()>>>,
     {
-        let id = self.init_resource::<SingleSuccessSystems>().next_id();
         self.stages
-            .add_system_to_stage(First, single_success_system(id, system));
+            .add_system_to_stage(First, single_success_system(Ulid::new(), system));
         self
     }
 
@@ -262,10 +266,14 @@ impl Drop for FinishGuard {
     }
 }
 
-/// Wrapper system for single success systems. Takes a system, and an `usize` id
-/// that is used to index whether or not the system has succeeded from the
-/// [`SingleSuccessSystems`] resource.
-fn single_success_system<Args, S>(id: usize, system: S) -> StaticSystem<(), ()>
+/// Wrapper system for single success systems.
+///
+/// Runs the given system each frame until it succeeds (returns Some). Uses
+/// `Option<()>` instead of a `bool` to allow for easy usage of `?`.
+///
+/// Takes a [`Ulid`] that is used to identify whether or not the system has
+/// succeeded from the [`SingleSuccessSystems`] resource.
+pub fn single_success_system<Args, S>(id: Ulid, system: S) -> StaticSystem<(), ()>
 where
     S: IntoSystem<Args, (), Option<()>, Sys = StaticSystem<(), Option<()>>>,
 {
@@ -283,35 +291,28 @@ where
     .system()
 }
 
-/// Resource tracking which of single success systems have completed.
-#[derive(HasSchema, Clone, Default)]
-pub struct SingleSuccessSystems {
-    /// Used for id creation as single success systems are added to the session.
-    last_id: usize,
-    /// Set of indices of single success systems that have succeeded.
-    pub systems_succeeded: HashSet<usize>,
-}
+/// Resource tracking which of single success systems have completed with a
+/// [`HashSet`] of [`Ulid`] for the succeeded.
+#[derive(HasSchema, Clone, Default, Deref, DerefMut)]
+pub struct SingleSuccessSystems(pub HashSet<Ulid>);
 
 impl SingleSuccessSystems {
-    /// Returns the next `usize` for the next single success system to use.
-    pub fn next_id(&mut self) -> usize {
-        self.last_id += 1;
-        self.last_id
-    }
     /// Reset single success systems completion status. so they run again until success.
-    #[allow(dead_code)]
+    #[inline]
     pub fn reset(&mut self) {
-        self.systems_succeeded.clear();
+        self.clear();
     }
 
     /// Check if system has completed
-    pub fn has_system_succeeded(&self, index: usize) -> bool {
-        self.systems_succeeded.contains(&index)
+    #[inline]
+    pub fn has_system_succeeded(&self, ulid: Ulid) -> bool {
+        self.contains(&ulid)
     }
 
     /// Mark system as completed.
-    pub fn set_system_completed(&mut self, index: usize) {
-        self.systems_succeeded.insert(index);
+    #[inline]
+    pub fn set_system_completed(&mut self, ulid: Ulid) {
+        self.insert(ulid);
     }
 }
 

From 7994b37d63415128037b0797cce3cca9bbfd537a Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Wed, 13 May 2026 16:23:41 -0500
Subject: [PATCH 11/36] refactor!: remove SessionRunner support requirements
 for ResetWorld. Changes ResetWorld functionality to reset resources by
 retention instead of "post replacement".

---
 .../bones_framework/src/networking.rs         |  19 +-
 .../bones_framework/tests/reset.rs            | 172 +++++++++---------
 framework_crates/bones_lib/src/lib.rs         |  15 +-
 framework_crates/bones_lib/src/reset.rs       | 137 ++++----------
 4 files changed, 137 insertions(+), 206 deletions(-)

diff --git a/framework_crates/bones_framework/src/networking.rs b/framework_crates/bones_framework/src/networking.rs
index 742333ebf3..a2096dee5b 100644
--- a/framework_crates/bones_framework/src/networking.rs
+++ b/framework_crates/bones_framework/src/networking.rs
@@ -808,6 +808,9 @@ where
                                     if world.resources.get::<RngGenerator>().is_none() {
                                         let rng_generator = RngGenerator::new(self.random_seed);
                                         world.insert_resource(rng_generator);
+                                        world
+                                            .init_resource::<ResetWorld>()
+                                            .retain_resource::<RngGenerator>();
                                     }
 
                                     // TODO: Make sure SyncingInfo is initialized immediately when session is created,
@@ -862,22 +865,6 @@ where
 
                                     // Run game session stages, advancing simulation
                                     stages.run(world);
-
-                                    // Handle any triggered resets of world + preserve runner's managed resources like RngGenerator.
-                                    if world.reset_triggered() {
-                                        let rng = world
-                                            .get_resource::<RngGenerator>()
-                                            .map(|r| (*r).clone());
-                                        if let Some(rng) = rng {
-                                            if let Some(mut reset) =
-                                                world.get_resource_mut::<ResetWorld>()
-                                            {
-                                                reset.insert_reset_resource(rng);
-                                            }
-                                        }
-
-                                        world.reset_internals();
-                                    }
                                 }
                             }
                         }
diff --git a/framework_crates/bones_framework/tests/reset.rs b/framework_crates/bones_framework/tests/reset.rs
index 7a0031a1f5..428bd6f382 100644
--- a/framework_crates/bones_framework/tests/reset.rs
+++ b/framework_crates/bones_framework/tests/reset.rs
@@ -26,19 +26,14 @@ pub fn startup_system_reset() {
     // Verify startup system ran and incremented only once
     assert_eq!(game.shared_resource::<Counter>().0, 1);
 
-    // Add command that will trigger reset on next step
+    // Reset the world; Equivalent to reseting at the start or end of the frame.
+    // `StartupSystemsRan` is inserted into the world to indicate completion,
+    // but is not retained so startup systems should run again.
     {
-        let game_session = game.sessions.get_mut("game").unwrap();
-        game_session.world.init_resource::<CommandQueue>().add(
-            |mut reset: ResMutInit<ResetWorld>| {
-                reset.reset = true;
-            },
-        );
+        let world = &game.sessions.get_mut("game").unwrap().world;
+        world.resource_mut::<ResetWorld>().reset_world(world);
     }
 
-    // step again, world should be reset. Startup doesn't run until next step though.
-    game.step(Instant::now());
-
     // step again to trigger startup
     game.step(Instant::now());
 
@@ -52,24 +47,25 @@ pub fn startup_system_reset() {
 pub fn single_success_system_reset() {
     let mut game = Game::new();
 
-    // Session startup increments counter by 1
     game.sessions
         .create_with("game", |builder: &mut SessionBuilder| {
-            builder.init_resource::<Counter>();
-            {
-                let res = builder.resource_mut::<Counter>().unwrap();
-                assert_eq!(res.0, 0);
-            }
-            // system
-            builder.add_single_success_system(|mut counter: ResMut<Counter>| -> Option<()> {
-                // Increment until 2
-                counter.0 += 1;
-                if counter.0 >= 2 {
-                    return Some(());
-                }
-
-                None
+            // Counter should not be retained on reset.
+            builder.add_system_to_stage(Startup, |world: &World| {
+                world.insert_resource(Counter(0));
             });
+            // Single success system increments counter by 1 until 2.
+            builder.add_system_to_stage(
+                First,
+                single_success_system(Ulid::new(), |mut counter: ResMut<Counter>| -> Option<()> {
+                    // Increment until 2
+                    counter.0 += 1;
+                    if counter.0 >= 2 {
+                        return Some(());
+                    }
+
+                    None
+                }),
+            );
         });
 
     // Step three times, single success should've incremented counter to 2 and completed.
@@ -77,39 +73,43 @@ pub fn single_success_system_reset() {
     game.step(Instant::now());
     game.step(Instant::now());
 
-    // Verify startup system ran and incremented only once
+    // Verify startup system ran and incremented only twice
     {
         let session = game.sessions.get("game").unwrap();
         let counter = session.world.get_resource::<Counter>().unwrap();
         assert_eq!(counter.0, 2);
     }
 
-    // Add command that will trigger reset on next step
+    // Reset the world; Equivalent to reseting at the start or end of the frame.
     {
-        let game_session = game.sessions.get_mut("game").unwrap();
-        game_session.world.init_resource::<CommandQueue>().add(
-            |mut reset: ResMutInit<ResetWorld>| {
-                reset.reset = true;
-            },
-        );
+        let world = &game.sessions.get_mut("game").unwrap().world;
+        world.resource_mut::<ResetWorld>().reset_world(world);
     }
 
-    // step again, world should be reset after this step. Counter should be back at default state of 0,
-    // single successs system not yet run until beginning of next step.
-    game.step(Instant::now());
+    // Counter & SingleSuccessSystems should not exist now.
     {
         let session = game.sessions.get("game").unwrap();
-        let counter = session.world.get_resource::<Counter>().unwrap();
-        assert_eq!(counter.0, 0);
+        let counter = session.world.get_resource::<Counter>();
+        assert!(counter.is_none());
+
+        let sss = session.world.get_resource::<SingleSuccessSystems>();
+        assert!(sss.is_none());
     }
 
-    // Startup resource should be re-initialized, and completion status of single single success system reset.
-    // It will run incrementing to 1.
+    // Counter resource should be re-initialized on CoreStage::Startup.
+    // SingleSuccessSystems should have no completions. The one "SSS" will run
+    // incrementing to 1 without completing.
     game.step(Instant::now());
     {
         let session = game.sessions.get("game").unwrap();
         let counter = session.world.get_resource::<Counter>().unwrap();
         assert_eq!(counter.0, 1);
+
+        let sss = session
+            .world
+            .get_resource::<SingleSuccessSystems>()
+            .unwrap();
+        assert!(sss.is_empty());
     }
 
     // Run a few more times, single success system should stop at 2:
@@ -120,86 +120,90 @@ pub fn single_success_system_reset() {
         let session = game.sessions.get("game").unwrap();
         let counter = session.world.get_resource::<Counter>().unwrap();
         assert_eq!(counter.0, 2);
+
+        let sss = session
+            .world
+            .get_resource::<SingleSuccessSystems>()
+            .unwrap();
+        assert!(!sss.is_empty());
     }
 }
 
 #[test]
-pub fn reset_world_resource_override() {
+pub fn reset_world_resource_retain() {
     let mut game = Game::new();
 
     // insert counter resource
     game.sessions
         .create_with("game", |builder: &mut SessionBuilder| {
-            builder.init_resource::<Counter>();
+            // This will put the resource into `ResetWorld`'s retained resources
+            // when built.
+            builder.insert_resource(Counter(2));
+            // Insert unit type on startup that won't be retained on reset.
+            builder.add_system_to_stage(Startup, |world: &World| {
+                world.insert_resource(());
+            });
         });
 
     game.step(Instant::now());
+
+    // assert Counter is still 2 & unit resource exists
     {
-        let session = game.sessions.get("game").unwrap();
-        let counter = session.world.get_resource::<Counter>().unwrap();
-        // asert in default state of 0
-        assert_eq!(counter.0, 0);
+        let world = &game.sessions.get("game").unwrap().world;
+        let counter = world.get_resource::<Counter>().unwrap();
+        assert_eq!(counter.0, 2);
+        let unit = world.get_resource::<()>();
+        assert!(unit.is_some());
     }
 
-    // Add command that will trigger reset on next step,
-    // and add reset resource of Counter with value 1
+    // Reset the world; Equivalent to reseting at the start or end of the frame.
+    // Counter should be retained since `SessionBuilder` inserts "startup
+    // resources" into `ResetWorld` when the session is built.
+    // Unit type was inserted in the Startup stage so should not be retained.
     {
-        let game_session = game.sessions.get_mut("game").unwrap();
-        game_session.world.init_resource::<CommandQueue>().add(
-            |mut reset: ResMutInit<ResetWorld>| {
-                reset.reset = true;
-                reset.insert_reset_resource(Counter(1));
-            },
-        );
+        let world = &game.sessions.get_mut("game").unwrap().world;
+        world.resource_mut::<ResetWorld>().reset_world(world);
     }
 
-    // Step to reset
-    game.step(Instant::now());
+    // Verify that Counter is still 2, instead of being removed.
+    // Verify counter is removed.
     {
-        let session = game.sessions.get("game").unwrap();
-        let counter = session.world.get_resource::<Counter>().unwrap();
-        // Verify the reset resource of value 1 was applied, instead of resetting to default state
-        assert_eq!(counter.0, 1);
+        let world = &game.sessions.get("game").unwrap().world;
+        let counter = world.get_resource::<Counter>().unwrap();
+        assert_eq!(counter.0, 2);
+        let unit = world.get_resource::<()>();
+        assert!(unit.is_none());
     }
 }
 
 #[test]
-pub fn reset_world_emtpy_resource() {
+pub fn reset_world_resource_drop() {
     let mut game = Game::new();
 
     // insert counter resource
     game.sessions
         .create_with("game", |builder: &mut SessionBuilder| {
-            builder.init_resource::<Counter>();
+            // This will put the resource into `ResetWorld`'s retained resources
+            // when built.
+            builder.insert_resource(Counter(2));
         });
 
     game.step(Instant::now());
+
+    // there are no systems but assert Counter is still 2
     {
         let session = game.sessions.get("game").unwrap();
         let counter = session.world.get_resource::<Counter>().unwrap();
-        // asert in default state of 0
-        assert_eq!(counter.0, 0);
-    }
-
-    // Add command that will trigger reset on next step,
-    // and add reset resource of Counter with value 1
-    {
-        let game_session = game.sessions.get_mut("game").unwrap();
-        game_session.world.init_resource::<CommandQueue>().add(
-            |mut reset: ResMutInit<ResetWorld>| {
-                reset.reset = true;
-                reset.insert_empty_reset_resource::<Counter>();
-            },
-        );
+        assert_eq!(counter.0, 2);
     }
-
-    // Step to reset
-    game.step(Instant::now());
+    // Reset the world; Equivalent to reseting at the start or end of the frame.
+    // Remove Counter from `ResetWorld`; It should not exist after the call.
     {
-        let session = game.sessions.get("game").unwrap();
-        let counter = session.world.get_resource::<Counter>();
+        let world = &game.sessions.get_mut("game").unwrap().world;
+        let mut reset = world.resource_mut::<ResetWorld>();
+        reset.drop_resource::<Counter>();
+        reset.reset_world(world);
 
-        // Verify resource was removed instead of reseting to initial state of session build.
-        assert!(counter.is_none())
+        assert!(world.get_resource::<Counter>().is_none());
     }
 }
diff --git a/framework_crates/bones_lib/src/lib.rs b/framework_crates/bones_lib/src/lib.rs
index 6211ce53a4..6e131435af 100644
--- a/framework_crates/bones_lib/src/lib.rs
+++ b/framework_crates/bones_lib/src/lib.rs
@@ -35,8 +35,7 @@ pub struct SessionBuilder {
     /// System stage builder
     pub stages: SystemStagesBuilder,
     /// Resources to be inserted into the world when finished building. Inserted
-    /// collectively into the world as the [`StartupResources`] resource to be
-    /// used by [`ResetWorld`] functionality.
+    /// collectively into the world as the [`StartupResources`] resource.
     pub startup_resources: UntypedResourceSet,
     /// Whether or not this session should have it's systems run.
     pub active: bool,
@@ -225,6 +224,12 @@ impl SessionBuilder {
             world: {
                 let w = World::default();
                 w.init_resource::<Time>();
+                {
+                    let mut reset = w.init_resource::<ResetWorld>();
+                    for untyped in self.startup_resources.resources() {
+                        reset.reset_resources.insert(untyped.schema().id());
+                    }
+                }
                 w
             },
             stages: self.stages.finish(),
@@ -248,7 +253,8 @@ impl SessionBuilder {
     }
 }
 
-/// Resource used for initializing resources on reset with [`ResetWorld`].
+/// This is currently just used for letting you create a [`SessionBuilder`] from
+/// a session.
 #[derive(HasSchema, Clone, Default, Deref, DerefMut)]
 pub struct StartupResources(pub UntypedResourceSet);
 
@@ -442,9 +448,6 @@ impl SessionRunner for DefaultSessionRunner {
     fn step(&mut self, now: instant::Instant, world: &mut World, stages: &mut SystemStages) {
         world.resource_mut::<Time>().update_with_instant(now);
         stages.run(world);
-
-        // Checks if reset of world has been triggered by [`ResetWorld`] and handles a reset.
-        world.handle_world_reset();
     }
 
     // This is a no-op as no state, but implemented this way in case that changes later.
diff --git a/framework_crates/bones_lib/src/reset.rs b/framework_crates/bones_lib/src/reset.rs
index cc9bab8ef1..7a008503f0 100644
--- a/framework_crates/bones_lib/src/reset.rs
+++ b/framework_crates/bones_lib/src/reset.rs
@@ -1,117 +1,54 @@
-//! Extensions of bones_ecs for utility functions in resetting a World
+//! Conveniences for resetting a World to its' startup state.
 use crate::prelude::*;
 
-/// Resource that allows user to trigger a reset of world, clearing entities, components, and resources.
-/// This is supported in bone's default session runners - but if implementing custom runner, must call `world.handle_world_reset` inside step.
+/// Convenience resource for reseting the [`World`] while retaining a selection of resources if desired.
 ///
-/// `reset_world: ResMutInit<ResetWorld>` and setting `reset_world.reset = true;` may be used to trigger a reset from system execution.
+/// See [`Self::reset_world`]
 #[derive(HasSchema, Clone, Default)]
 pub struct ResetWorld {
-    /// Set to true to trigger reset of [`World`].
-    pub reset: bool,
-
-    /// List of resources that will be inserted into [`World`] after the resources are reset,
-    /// before startup systems are executed.
-    /// These override any `startup resources` captured during session build.
-    /// If want to preserve a resource instead of having it reset, insert it here.
-    pub reset_resources: UntypedResourceSet,
+    /// Set of [`SchemaId`]s for the resources that will not be removed from the
+    /// world when calling [`Self::reset_world`].
+    pub reset_resources: HashSet<SchemaId>,
 }
 
 impl ResetWorld {
-    /// Insert a resource that will be applied after reset. If resource was created
-    /// on session iniialization, this will overwrite it using reset resource instead.
-    pub fn insert_reset_resource<T: HasSchema>(&mut self, resource: T) {
-        self.reset_resources.insert_resource(resource);
+    /// Adds the [`SchemaId`] of the type given to the set of resources to
+    /// retain on reset.
+    pub fn retain_resource<T: HasSchema>(&mut self) {
+        self.reset_resources.insert(T::schema().id());
     }
 
-    /// Get a mutable reference to a reset resource if found.
-    pub fn reset_resource_mut<T: HasSchema>(&self) -> Option<RefMut<'_, T>> {
-        self.reset_resources.resource_mut::<T>()
+    /// Removes the [`SchemaId`] of the type given from the set of resources to
+    /// retain on reset.
+    pub fn drop_resource<T: HasSchema>(&mut self) {
+        self.reset_resources.remove(&T::schema().id());
     }
 
-    /// Insert resource in "empty" state - If resource was created
-    /// on session iniialization, instead of being reset to that state,
-    /// after reset this resource will not be on [`World`].
-    pub fn insert_empty_reset_resource<T: HasSchema>(&mut self) {
-        self.reset_resources.insert_empty::<T>();
-    }
-}
-
-/// Extension of [`World`]
-pub trait WorldExt {
-    /// May be called by [`SessionRunner`] before or after [`SystemStages::run`] to allow triggering reset
-    /// of world with the [`ResetWorld`] resource.
+    /// Convenience method for reseting the [`World`]. Clears components,
+    /// entities, and resources out of the world.
     ///
-    /// `stages` is required, so that after reset, will immediatelly run startup tasks, instead of waiting until next step of [`SystemStages`].
-    /// This avoids edge cases where other sessions may read expected resources from this session before its next step.
-    fn handle_world_reset(&mut self);
-
-    /// Check if reset has been triggered by [`ResetWorld`] resource. If [`SessionRunner`] needs to do anything special
-    /// for a world reset (preserve managed resources, etc) - can check this before calling `handle_world_reset` to see
-    /// if a rese will occur.
-    fn reset_triggered(&self) -> bool;
-
-    /// Provides a low-level interface for resetting entities, components, and resources.
+    /// Resources in [`self.reset_resources`](Self::reset_resources) field are
+    /// not removed from the world and can be easily added via
+    /// [`Self::retain_resource`] or removed via [`Self::drop_resource`].
     ///
-    /// `stages` is required, so that after reset, will immediatelly run startup tasks, instead of waiting until next step of [`SystemStages`].
-    /// This avoids edge cases where other sessions may read expected resources from this session before its next step.
+    /// [`Entities`], [`Time`], [`SessionOptions`], and [`ResetWorld`] are
+    /// always retained when calling.
     ///
-    /// Waring: Calling this function on World in a [`Session`] using network session runner is likely to introduce non-determinism.
-    /// It is strongly recommended to use the [`ResetWorld`] Resource to trigger this in manner compatible with net rollback.
-    fn reset_internals(&mut self);
-}
-
-impl WorldExt for World {
-    fn handle_world_reset(&mut self) {
-        if self.reset_triggered() {
-            self.reset_internals();
-        }
-    }
-
-    fn reset_triggered(&self) -> bool {
-        self.get_resource::<ResetWorld>().is_some_and(|r| r.reset)
-    }
-
-    fn reset_internals(&mut self) {
-        // Clear all component stores
-        self.components = ComponentStores::default();
-
-        // move out special resources that should always remain in session / managed by bones
-        let time = self.resources.remove::<Time>();
-        let session_opts = self.resources.remove::<SessionOptions>();
-        let startup_resources = self.resources.remove::<StartupResources>();
-
-        let post_reset_resources = self
-            .resources
-            .remove::<ResetWorld>()
-            .map(|r| r.reset_resources);
-
-        // Remove any owned resources (preserves shared resources)
-        // This allows world resources to be reset inside session run safely, as shared resources are only injected
-        // outside of session run, and a runner may take another step after the reset.
-        self.resources.clear_owned_resources();
-
-        // Entities were cleared with resources - ensure is present.
-        self.init_resource::<Entities>();
-
-        // Re-insert preserved resources
-        if let Some(time) = time {
-            self.insert_resource(time);
-        }
-        if let Some(session_opts) = session_opts {
-            self.insert_resource(session_opts);
-        }
-
-        // Insert startup resources.
-        if let Some(resources) = startup_resources {
-            let remove_empty = true;
-            resources.insert_on_world(self, remove_empty);
-        }
-
-        // Apply any reset resources to world, overwriting startup resources.
-        if let Some(resources) = post_reset_resources {
-            let remove_empty = true;
-            resources.insert_on_world(self, remove_empty);
-        }
+    /// This should likely be the first call in your systems so that components
+    /// are rendered continuously without dropping out for one frame before
+    /// respawning world startup components.
+    ///
+    /// Safe to call while borrowing `Self` as a resource from the world without
+    /// panicking.
+    pub fn reset_world(&mut self, world: &World) {
+        self.retain_resource::<ResetWorld>(); // This prevents a mutable borrow in `retain_owned_resources`.
+        self.retain_resource::<Entities>();
+        self.retain_resource::<Time>(); // TODO: make sure we need the `Time` resource retained.
+        self.retain_resource::<SessionOptions>();
+
+        world.resource_mut::<Entities>().kill_all(); // `kill_all` for component clearing
+        world.maintain(); // clear components
+        *world.resource_mut::<Entities>() = Entities::default(); // fully reset entities
+        world.retain_owned_resources(|schema_id| self.reset_resources.contains(&schema_id));
     }
 }

From 98ebf2f6eef6be27ac6a22bc3aacdd2f6bb77977 Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Wed, 13 May 2026 18:45:37 -0500
Subject: [PATCH 12/36] chore: remove uneeded mutable reference

---
 framework_crates/bones_ecs/src/resources.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/framework_crates/bones_ecs/src/resources.rs b/framework_crates/bones_ecs/src/resources.rs
index a775160408..c76f82dc2c 100644
--- a/framework_crates/bones_ecs/src/resources.rs
+++ b/framework_crates/bones_ecs/src/resources.rs
@@ -578,7 +578,7 @@ impl UntypedResourceSet {
     ///
     /// If `remove_empty` is set, if resource cell is empty, it will remove the
     /// resource from cell on world.
-    pub fn insert_on_world(&self, world: &mut World, remove_empty: bool) {
+    pub fn insert_on_world(&self, world: &World, remove_empty: bool) {
         for resource in self.resources.iter() {
             let resource_cell = world.resources.untyped().get_cell(resource.schema());
 

From b20c6fda5ae2a33b960830a6e8fbf59d8f4845ad Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Thu, 14 May 2026 12:58:10 -0500
Subject: [PATCH 13/36] doc: clarify `insert_resource`

---
 framework_crates/bones_ecs/src/world.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/framework_crates/bones_ecs/src/world.rs b/framework_crates/bones_ecs/src/world.rs
index 67f8a54337..ebac88d70c 100644
--- a/framework_crates/bones_ecs/src/world.rs
+++ b/framework_crates/bones_ecs/src/world.rs
@@ -138,7 +138,7 @@ impl World {
         self.resource_mut()
     }
 
-    /// Insert a resource.
+    /// Insert a resource, replacing it if it already exists.
     pub fn insert_resource<R: HasSchema>(&self, resource: R) -> Option<R> {
         self.resources.insert(resource)
     }

From 7565ddb50277bc1c4f8820d52f4e00c86de0b026 Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Thu, 14 May 2026 13:05:52 -0500
Subject: [PATCH 14/36] doc: clarify SessionCommand activation timing

---
 framework_crates/bones_lib/src/lib.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/framework_crates/bones_lib/src/lib.rs b/framework_crates/bones_lib/src/lib.rs
index 6e131435af..498bb74372 100644
--- a/framework_crates/bones_lib/src/lib.rs
+++ b/framework_crates/bones_lib/src/lib.rs
@@ -859,10 +859,12 @@ pub struct Sessions {
     /// Commands that operate on [`Sessions`], called after all sessions update.
     /// These may be used to add/delete/modify sessions.
     ///
-    /// Commands are useful in a situation where you want to remove / recreate
-    /// a session from within it's own system. You cannot do this while the `Session` is running.
+    /// Commands are useful in a situation where you want to remove / recreate a
+    /// session from within it's own system. You cannot do this while the
+    /// `Session` is running.
     ///
-    /// Commands added inside a session command will not be executed until next frame.
+    /// Commands added inside a session command will not be executed until after
+    /// the frame they were inserted.
     commands: VecDeque<Box<SessionCommand>>,
 }
 

From 9a0af60ecf7add4fc4d0e5e97f43296366c79752 Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Sun, 17 May 2026 13:02:00 -0500
Subject: [PATCH 15/36] refactor!: SystemStages, Session, and ResetWorld

Moves Session system methods to SystemStages since Session derefs to its stages.
Remove SessionBuilder & SystemStagesBuilder in favor of simplification and a more open capability. The limitations set by these builders were not fullproof and making them so sacrifices too much. A more limiting / safe layer likely belongs at the higher level and can be decided on better after more games have been made.
---
 demos/asset_packs/src/main.rs                 |  12 +-
 demos/assets_minimal/src/main.rs              |  10 +-
 demos/features/src/main.rs                    |  16 +-
 demos/hello_world/src/main.rs                 |  12 +-
 demos/scripting/src/main.rs                   |  24 +-
 .../bones_ecs/examples/pos_vel.rs             |   7 +-
 framework_crates/bones_ecs/src/stage.rs       | 206 ++++++---
 .../bones_framework/src/animation.rs          |   2 +-
 framework_crates/bones_framework/src/audio.rs |   3 +-
 framework_crates/bones_framework/src/debug.rs |   2 +-
 framework_crates/bones_framework/src/lib.rs   |   2 +-
 .../bones_framework/src/networking.rs         |   5 +-
 .../bones_framework/src/networking/debug.rs   |   2 +-
 .../bones_framework/src/render.rs             |   2 +-
 .../bones_framework/src/render/camera.rs      |   2 +-
 .../bones_framework/src/render/sprite.rs      |   2 +-
 .../bones_framework/src/render/ui.rs          |   2 +-
 .../bones_framework/tests/reset.rs            | 147 +++---
 framework_crates/bones_lib/src/lib.rs         | 419 ++----------------
 framework_crates/bones_lib/src/reset.rs       |  97 ++--
 framework_crates/bones_scripting/src/lua.rs   |   4 +-
 21 files changed, 355 insertions(+), 623 deletions(-)

diff --git a/demos/asset_packs/src/main.rs b/demos/asset_packs/src/main.rs
index 8bb247882a..75c6656db3 100644
--- a/demos/asset_packs/src/main.rs
+++ b/demos/asset_packs/src/main.rs
@@ -47,13 +47,11 @@ fn main() {
     // Create a new session for the game menu. Each session is it's own bones world with it's own
     // plugins, systems, and entities.
     game.sessions
-        .create_with("menu", |builder: &mut SessionBuilder| {
-            // Install the default bones_framework plugin for this session
-            builder
-                .install_plugin(DefaultSessionPlugin)
-                // Add our menu system to the update stage
-                .add_system_to_stage(Update, menu_system);
-        });
+        .create("menu")
+        // Install the default bones_framework plugin for this session
+        .install_plugin(DefaultSessionPlugin)
+        // Add our menu system to the update stage
+        .add_system_to_stage(Update, menu_system);
 
     BonesBevyRenderer::new(game).app().run();
 }
diff --git a/demos/assets_minimal/src/main.rs b/demos/assets_minimal/src/main.rs
index b49b7c0a01..a69ecb7841 100644
--- a/demos/assets_minimal/src/main.rs
+++ b/demos/assets_minimal/src/main.rs
@@ -36,17 +36,13 @@ fn main() {
 
     // Create a new session for the game menu. Each session is it's own bones world with it's own
     // plugins, systems, and entities.
-    let mut menu_session_builder = SessionBuilder::new("menu");
-
-    // Install the default bones_framework plugin for this session
-    menu_session_builder
+    game.sessions
+        .create("menu")
+        // Install the default bones_framework plugin for this session
         .install_plugin(DefaultSessionPlugin)
         // Add our menu system to the update stage
         .add_system_to_stage(Update, menu_system);
 
-    // Finalize session and register with game sessions.
-    menu_session_builder.finish_and_add(&mut game.sessions);
-
     BonesBevyRenderer::new(game).app().run();
 }
 
diff --git a/demos/features/src/main.rs b/demos/features/src/main.rs
index 85a0968b24..3edcb371ef 100644
--- a/demos/features/src/main.rs
+++ b/demos/features/src/main.rs
@@ -139,13 +139,13 @@ struct MenuData {
 }
 
 /// Menu plugin
-pub fn menu_plugin(session: &mut SessionBuilder) {
+pub fn menu_plugin(session: &mut Session) {
     // Register our menu system
     session
         // Install the bones_framework default plugins for this session
         .install_plugin(DefaultSessionPlugin)
         // Initialize our menu data resource
-        .init_resource::<MenuData>();
+        .init_startup_resource::<MenuData>();
 
     // And add our systems.
     session
@@ -280,7 +280,7 @@ fn menu_system(
 }
 
 /// Plugin for running the sprite demo.
-fn sprite_demo_plugin(session: &mut SessionBuilder) {
+fn sprite_demo_plugin(session: &mut Session) {
     session
         .install_plugin(DefaultSessionPlugin)
         .add_system_to_stage(CoreStage::Startup, sprite_demo_startup)
@@ -344,7 +344,7 @@ fn move_sprite(
 }
 
 /// Plugin for running the tilemap demo.
-fn tilemap_demo_plugin(session: &mut SessionBuilder) {
+fn tilemap_demo_plugin(session: &mut Session) {
     session
         .install_plugin(DefaultSessionPlugin)
         .add_system_to_stage(CoreStage::Startup, tilemap_startup_system)
@@ -390,7 +390,7 @@ fn tilemap_startup_system(
 }
 
 /// Plugin for running the atlas demo.
-fn atlas_demo_plugin(session: &mut SessionBuilder) {
+fn atlas_demo_plugin(session: &mut Session) {
     session
         .install_plugin(DefaultSessionPlugin)
         .add_system_to_stage(CoreStage::Startup, atlas_demo_startup)
@@ -438,7 +438,7 @@ fn atlas_demo_startup(
     );
 }
 
-fn audio_demo_plugin(session: &mut SessionBuilder) {
+fn audio_demo_plugin(session: &mut Session) {
     session
         .install_plugin(DefaultSessionPlugin)
         .add_system_to_stage(Update, back_to_menu_ui)
@@ -464,7 +464,7 @@ fn audio_demo_ui(
         });
 }
 
-fn storage_demo_plugin(session: &mut SessionBuilder) {
+fn storage_demo_plugin(session: &mut Session) {
     session
         .install_plugin(DefaultSessionPlugin)
         .add_system_to_stage(Update, storage_demo_ui)
@@ -494,7 +494,7 @@ fn storage_demo_ui(
     });
 }
 
-fn path2d_demo_plugin(session: &mut SessionBuilder) {
+fn path2d_demo_plugin(session: &mut Session) {
     session
         .install_plugin(DefaultSessionPlugin)
         .add_system_to_stage(CoreStage::Startup, path2d_demo_startup)
diff --git a/demos/hello_world/src/main.rs b/demos/hello_world/src/main.rs
index b2931bfa4d..d3b0420765 100644
--- a/demos/hello_world/src/main.rs
+++ b/demos/hello_world/src/main.rs
@@ -11,13 +11,11 @@ fn main() {
     // Create a new session for the game menu. Each session is it's own bones world with it's own
     // plugins, systems, and entities.
     game.sessions
-        .create_with("menu", |session: &mut SessionBuilder| {
-            session
-                // Install the default bones_framework plugin for this session
-                .install_plugin(DefaultSessionPlugin)
-                // Add our menu system to the update stage
-                .add_system_to_stage(Update, menu_system);
-        });
+        .create("menu")
+        // Install the default bones_framework plugin for this session
+        .install_plugin(DefaultSessionPlugin)
+        // Add our menu system to the update stage
+        .add_system_to_stage(Update, menu_system);
 
     BonesBevyRenderer::new(game).app().run();
 }
diff --git a/demos/scripting/src/main.rs b/demos/scripting/src/main.rs
index cfcad810f1..fb81cce18d 100644
--- a/demos/scripting/src/main.rs
+++ b/demos/scripting/src/main.rs
@@ -23,9 +23,8 @@ fn main() {
     GameMeta::register_schema();
 
     game.sessions
-        .create_with("launch", |builder: &mut SessionBuilder| {
-            builder.add_system_to_stage(CoreStage::Startup, launch_game_session);
-        });
+        .create("launch")
+        .add_system_to_stage(CoreStage::Startup, launch_game_session);
 
     let mut renderer = BonesBevyRenderer::new(game);
     renderer.app_namespace = (
@@ -43,16 +42,15 @@ fn launch_game_session(
 ) {
     session_ops.delete = true;
     // Build game session and add to `Sessions`
-    sessions.create_with("game", |builder: &mut SessionBuilder| {
-        builder
-            .install_plugin(DefaultSessionPlugin)
-            // Install the plugin that will load our lua plugins and run them in the game session
-            .install_plugin(LuaPluginLoaderSessionPlugin(
-                // Tell it to install the lua plugins specified in our game meta
-                Arc::new(meta.plugins.iter().copied().collect()),
-            ))
-            .add_system_to_stage(CoreStage::Startup, game_startup);
-    });
+    sessions
+        .create("game")
+        .install_plugin(DefaultSessionPlugin)
+        // Install the plugin that will load our lua plugins and run them in the game session
+        .install_plugin(LuaPluginLoaderSessionPlugin(
+            // Tell it to install the lua plugins specified in our game meta
+            Arc::new(meta.plugins.iter().copied().collect()),
+        ))
+        .add_system_to_stage(CoreStage::Startup, game_startup);
 }
 
 fn game_startup(
diff --git a/framework_crates/bones_ecs/examples/pos_vel.rs b/framework_crates/bones_ecs/examples/pos_vel.rs
index 31dbbcddf1..fba37e4944 100644
--- a/framework_crates/bones_ecs/examples/pos_vel.rs
+++ b/framework_crates/bones_ecs/examples/pos_vel.rs
@@ -23,17 +23,14 @@ fn main() {
     let mut world = World::new();
 
     // Build SystemStages to store the systems that we will run more than once.
-    let mut stages_builder = SystemStagesBuilder::with_core_stages();
+    let mut stages = SystemStages::with_core_stages();
 
     // Add our systems to the system stages
-    stages_builder
+    stages
         .add_system_to_stage(CoreStage::Startup, startup_system)
         .add_system_to_stage(CoreStage::Update, pos_vel_system)
         .add_system_to_stage(CoreStage::PostUpdate, print_system);
 
-    // Finish build to get `SystemStages`.
-    let mut stages = stages_builder.finish();
-
     // Run our game loop for 10 frames
     for _ in 0..10 {
         stages.run(&mut world);
diff --git a/framework_crates/bones_ecs/src/stage.rs b/framework_crates/bones_ecs/src/stage.rs
index dc8af78fec..24b6f0cf53 100644
--- a/framework_crates/bones_ecs/src/stage.rs
+++ b/framework_crates/bones_ecs/src/stage.rs
@@ -10,20 +10,20 @@ use crate::prelude::*;
 #[derive(Deref, DerefMut, Clone, Copy, HasSchema, Default)]
 pub struct CurrentSystemStage(pub Ulid);
 
-/// Builder for [`SystemStages`]. It is immutable once created,
-pub struct SystemStagesBuilder {
+/// An ordered collection of [`SystemStage`]s.
+pub struct SystemStages {
     /// The stages in the collection, in the order that they will be run.
     stages: Vec<Box<dyn SystemStage>>,
 }
 
-impl Default for SystemStagesBuilder {
+impl Default for SystemStages {
     fn default() -> Self {
         Self::with_core_stages()
     }
 }
 
-impl SystemStagesBuilder {
-    /// Create a [`SystemStagesBuilder`] for [`SystemStages`] collection, initialized with a stage for each [`CoreStage`].
+impl SystemStages {
+    /// Create a [`SystemStages`] collection, initialized with a stage for each [`CoreStage`].
     pub fn with_core_stages() -> Self {
         Self {
             stages: vec![
@@ -37,32 +37,6 @@ impl SystemStagesBuilder {
         }
     }
 
-    /// Finish building and convert to [`SystemStages`]
-    pub fn finish(self) -> SystemStages {
-        SystemStages {
-            stages: self.stages,
-        }
-    }
-
-    /// Create [`SystemStagesBuilder`] by taking existing [`SystemStages`].
-    pub fn from_stages(stages: SystemStages) -> Self {
-        Self {
-            stages: stages.stages,
-        }
-    }
-
-    /// Add a system to the [`CoreStage::Startup`] stage which specially runs
-    /// only once, before all other core stages. Inserting [`StartupSystemsRan`]
-    /// into the world prevents systems in the startup stage from running.
-    #[deprecated = "use `.add_system_to_stage(CoreStage::Startup, your_system)` instead"]
-    pub fn add_startup_system<Args, S>(&mut self, system: S) -> &mut Self
-    where
-        S: IntoSystem<Args, (), (), Sys = StaticSystem<(), ()>>,
-    {
-        self.add_system_to_stage(CoreStage::Startup, system.system());
-        self
-    }
-
     /// Add a [`System`] to the stage with the given label.
     pub fn add_system_to_stage<Args, S>(&mut self, label: impl StageLabel, system: S) -> &mut Self
     where
@@ -120,35 +94,6 @@ impl SystemStagesBuilder {
 
         self
     }
-}
-
-/// An ordered collection of [`SystemStage`]s.
-pub struct SystemStages {
-    /// The stages in the collection, in the order that they will be run.
-    stages: Vec<Box<dyn SystemStage>>,
-}
-
-impl std::fmt::Debug for SystemStages {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("SystemStages")
-            // TODO: Add list of stages to the debug render for `SystemStages`.
-            // We can at least list the names of each stage for `SystemStages` debug
-            // implementation.
-            .finish()
-    }
-}
-
-impl Default for SystemStages {
-    fn default() -> Self {
-        SystemStagesBuilder::default().finish()
-    }
-}
-
-impl SystemStages {
-    /// Create builder for construction of [`SystemStages`].
-    pub fn builder() -> SystemStagesBuilder {
-        SystemStagesBuilder::default()
-    }
 
     /// Execute the systems on the given `world`.
     pub fn run(&mut self, world: &mut World) {
@@ -167,6 +112,97 @@ impl SystemStages {
         // Remove the current system stage resource
         world.resources.remove::<CurrentSystemStage>();
     }
+
+    /// Add a system to the [`CoreStage::Startup`] stage which specially runs
+    /// only once, before all other core stages. Inserting [`StartupSystemsRan`]
+    /// into the world prevents systems in the startup stage from running.
+    #[deprecated = "use `.add_system_to_stage(CoreStage::Startup, your_system)` instead"]
+    pub fn add_startup_system<Args, S>(&mut self, system: S) -> &mut Self
+    where
+        S: IntoSystem<Args, (), (), Sys = StaticSystem<(), ()>>,
+    {
+        self.add_system_to_stage(CoreStage::Startup, system.system());
+        self
+    }
+
+    /// Convenience method. Adds a system that will run each frame until it succeeds (returns Some).
+    /// Uses Option to allow for easy usage of `?`. System is added to
+    /// [`CoreStage::First`].
+    ///
+    /// See also the wrapper function used inside [`single_success_system`].
+    #[deprecated = "use `.add_system_to_stage(First, single_success_system(Ulid::new(), your_system)"]
+    pub fn add_single_success_system<Args, S>(&mut self, system: S) -> &mut Self
+    where
+        S: IntoSystem<Args, (), Option<()>, Sys = StaticSystem<(), Option<()>>>,
+    {
+        self.add_system_to_stage(First, single_success_system(Ulid::new(), system));
+        self
+    }
+
+    /// Adds a system to [`CoreStage::Startup`] that inserts the default value
+    /// of a resource into the [`World`] if it doesn't already exist.
+    pub fn init_startup_resource<R: HasSchema + FromWorld>(&mut self) -> &mut Self {
+        self.add_system_to_stage(Startup, |world: &World| {
+            world.init_resource::<R>();
+        });
+        self
+    }
+
+    /// Adds a system to [`CoreStage::Startup`] that inserts the given resource
+    /// into the [`World`] if it doesn't already exist. The resource type is
+    /// required to have a [`HasSchema`] clone implementation to re-insert the
+    /// resource into the world after the first startup.
+    ///
+    /// # Clone Requirement Details
+    /// If the type being added implements [`HasSchema`] with the derive like
+    /// so:
+    /// ```ignore
+    /// #[derive(HasSchema, Default)]
+    /// #[schema(no_clone)] // This bypasses HasSchema clone requirements.
+    /// struct ResourceBeingInserted;
+    /// ```
+    /// Then the system being added to the [`Startup`] system stage will panic
+    /// when inserting a second time.
+    pub fn add_startup_resource<R: HasSchema>(&mut self, resource: R) -> &mut Self {
+        let mut once = Some(SchemaBox::new(resource));
+
+        self.add_system_to_stage(Startup, move |world: &World| {
+            if !world.resources.contains::<R>() {
+                let schema_box = if R::schema().clone_fn.is_some() {
+                    once.clone()
+                } else {
+                    once.take()
+                };
+
+                if let Some(schema_box) = schema_box {
+                    world
+                        .resources
+                        .untyped()
+                        .get(R::schema())
+                        .insert(schema_box)
+                        .unwrap();
+                } else {
+                    panic!(
+                        "The schema for this type does not allow cloning it.\nSchema: {:#?}; \
+                    You may need to add the resource to the `ResetWorld::reset_resources` \
+                    to avoid cloning on startup.",
+                        R::schema()
+                    )
+                };
+            }
+        });
+        self
+    }
+}
+
+impl std::fmt::Debug for SystemStages {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("SystemStages")
+            // TODO: Add list of stages to the debug render for `SystemStages`.
+            // We can at least list the names of each stage for `SystemStages` debug
+            // implementation.
+            .finish()
+    }
 }
 
 /// Trait for system stages. A stage is a
@@ -302,6 +338,56 @@ impl SystemStage for StartupSystemStage {
     }
 }
 
+/// Wrapper system for single success systems.
+///
+/// Runs the given system each frame until it succeeds (returns Some). Uses
+/// `Option<()>` instead of a `bool` to allow for easy usage of `?`.
+///
+/// Takes a [`Ulid`] that is used to identify whether or not the system has
+/// succeeded from the [`SingleSuccessSystems`] resource.
+pub fn single_success_system<Args, S>(id: Ulid, system: S) -> StaticSystem<(), ()>
+where
+    S: IntoSystem<Args, (), Option<()>, Sys = StaticSystem<(), Option<()>>>,
+{
+    let mut system = system.system();
+    (move |world: &World| {
+        let succeeded = world
+            .init_resource::<SingleSuccessSystems>()
+            .has_system_succeeded(id);
+        if !succeeded && system.run(world, ()).is_some() {
+            world
+                .init_resource::<SingleSuccessSystems>()
+                .set_system_completed(id);
+        }
+    })
+    .system()
+}
+
+/// Resource tracking which of single success systems have completed with a
+/// [`HashSet`] of [`Ulid`] for the succeeded.
+#[derive(HasSchema, Clone, Default, Deref, DerefMut)]
+pub struct SingleSuccessSystems(pub HashSet<Ulid>);
+
+impl SingleSuccessSystems {
+    /// Reset single success systems completion status. so they run again until success.
+    #[inline]
+    pub fn reset(&mut self) {
+        self.clear();
+    }
+
+    /// Check if system has completed
+    #[inline]
+    pub fn has_system_succeeded(&self, ulid: Ulid) -> bool {
+        self.contains(&ulid)
+    }
+
+    /// Mark system as completed.
+    #[inline]
+    pub fn set_system_completed(&mut self, ulid: Ulid) {
+        self.insert(ulid);
+    }
+}
+
 /// Trait for things that may be used to identify a system stage.
 pub trait StageLabel {
     /// Returns the human-readable name of the label, used in error messages.
diff --git a/framework_crates/bones_framework/src/animation.rs b/framework_crates/bones_framework/src/animation.rs
index 159b244441..0d58421f41 100644
--- a/framework_crates/bones_framework/src/animation.rs
+++ b/framework_crates/bones_framework/src/animation.rs
@@ -3,7 +3,7 @@
 use crate::prelude::*;
 
 /// Install animation utilities into the given [`SystemStages`].
-pub fn animation_plugin(core: &mut SessionBuilder) {
+pub fn animation_plugin(core: &mut Session) {
     core.stages
         .add_system_to_stage(CoreStage::Last, update_animation_banks)
         .add_system_to_stage(CoreStage::Last, animate_sprites);
diff --git a/framework_crates/bones_framework/src/audio.rs b/framework_crates/bones_framework/src/audio.rs
index 447b03fd4b..08069e57b6 100644
--- a/framework_crates/bones_framework/src/audio.rs
+++ b/framework_crates/bones_framework/src/audio.rs
@@ -20,13 +20,12 @@ pub fn game_plugin(game: &mut Game) {
     game.insert_shared_resource(AudioManager::default());
     game.init_shared_resource::<AssetServer>();
 
-    let mut session = SessionBuilder::new(DEFAULT_BONES_AUDIO_SESSION);
+    let session = game.sessions.create(DEFAULT_BONES_AUDIO_SESSION);
     // Audio doesn't do any rendering
     session.visible = false;
     session
         .add_system_to_stage(First, _process_audio_events)
         .add_system_to_stage(Last, _kill_finished_audios);
-    session.finish_and_add(&mut game.sessions);
 }
 
 /// Holds the handles and the volume to be played for a piece of Audio.
diff --git a/framework_crates/bones_framework/src/debug.rs b/framework_crates/bones_framework/src/debug.rs
index 33f3c80c8b..facfdfce1d 100644
--- a/framework_crates/bones_framework/src/debug.rs
+++ b/framework_crates/bones_framework/src/debug.rs
@@ -51,7 +51,7 @@ pub struct FrameTimeWindowState {
 
 /// If installed, allows opening egui window with [`FrameTimeWindowState`] in [`EguiCtx`] state
 /// to get frame time information.
-pub fn frame_time_diagnostics_plugin(core: &mut SessionBuilder) {
+pub fn frame_time_diagnostics_plugin(core: &mut Session) {
     core.stages
         .add_system_to_stage(CoreStage::Last, frame_diagnostic_window);
 }
diff --git a/framework_crates/bones_framework/src/lib.rs b/framework_crates/bones_framework/src/lib.rs
index f2629410ed..88adc57a33 100644
--- a/framework_crates/bones_framework/src/lib.rs
+++ b/framework_crates/bones_framework/src/lib.rs
@@ -91,7 +91,7 @@ pub mod external {
 /// Default plugins for bones framework sessions.
 pub struct DefaultSessionPlugin;
 impl lib::SessionPlugin for DefaultSessionPlugin {
-    fn install(self, session: &mut lib::SessionBuilder) {
+    fn install(self, session: &mut lib::Session) {
         session
             .install_plugin(animation::animation_plugin)
             .install_plugin(render::render_plugin);
diff --git a/framework_crates/bones_framework/src/networking.rs b/framework_crates/bones_framework/src/networking.rs
index a2096dee5b..ab6bac4097 100644
--- a/framework_crates/bones_framework/src/networking.rs
+++ b/framework_crates/bones_framework/src/networking.rs
@@ -808,9 +808,6 @@ where
                                     if world.resources.get::<RngGenerator>().is_none() {
                                         let rng_generator = RngGenerator::new(self.random_seed);
                                         world.insert_resource(rng_generator);
-                                        world
-                                            .init_resource::<ResetWorld>()
-                                            .retain_resource::<RngGenerator>();
                                     }
 
                                     // TODO: Make sure SyncingInfo is initialized immediately when session is created,
@@ -841,7 +838,7 @@ where
 
                                     {
                                         world
-                                            .resource_mut::<Time>()
+                                            .init_resource::<Time>()
                                             .advance_exact(Duration::from_secs_f64(step));
 
                                         // update game controls from ggrs inputs
diff --git a/framework_crates/bones_framework/src/networking/debug.rs b/framework_crates/bones_framework/src/networking/debug.rs
index 055b60a976..924bb7d8bc 100644
--- a/framework_crates/bones_framework/src/networking/debug.rs
+++ b/framework_crates/bones_framework/src/networking/debug.rs
@@ -25,7 +25,7 @@ pub mod prelude {
 /// Session plugin for network debug window. Is not installed by default.
 /// After installing plugin, [`NetworkDebugMenuState`] on [`EguiCtx`] state
 /// may be modified to open menu.
-pub fn network_debug_session_plugin(session: &mut SessionBuilder) {
+pub fn network_debug_session_plugin(session: &mut Session) {
     session.add_system_to_stage(CoreStage::First, network_debug_window);
 }
 
diff --git a/framework_crates/bones_framework/src/render.rs b/framework_crates/bones_framework/src/render.rs
index b8cfdd0793..ba58566c45 100644
--- a/framework_crates/bones_framework/src/render.rs
+++ b/framework_crates/bones_framework/src/render.rs
@@ -24,7 +24,7 @@ pub mod transform;
 pub mod ui;
 
 /// Bones framework rendering plugin.
-pub fn render_plugin(session: &mut SessionBuilder) {
+pub fn render_plugin(session: &mut Session) {
     session
         .install_plugin(sprite::sprite_plugin)
         .install_plugin(camera::plugin);
diff --git a/framework_crates/bones_framework/src/render/camera.rs b/framework_crates/bones_framework/src/render/camera.rs
index 794cfda293..a12d9e1625 100644
--- a/framework_crates/bones_framework/src/render/camera.rs
+++ b/framework_crates/bones_framework/src/render/camera.rs
@@ -125,7 +125,7 @@ pub fn spawn_default_camera(
 }
 
 /// Install the camera utilities on the given [`SystemStages`].
-pub fn plugin(session: &mut SessionBuilder) {
+pub fn plugin(session: &mut Session) {
     session
         .stages
         .add_system_to_stage(CoreStage::Last, apply_shake)
diff --git a/framework_crates/bones_framework/src/render/sprite.rs b/framework_crates/bones_framework/src/render/sprite.rs
index b4cb2456a1..5a6e6519bd 100644
--- a/framework_crates/bones_framework/src/render/sprite.rs
+++ b/framework_crates/bones_framework/src/render/sprite.rs
@@ -3,7 +3,7 @@
 use crate::prelude::*;
 
 /// Sprite session plugin.
-pub fn sprite_plugin(_session: &mut SessionBuilder) {
+pub fn sprite_plugin(_session: &mut Session) {
     Sprite::register_schema();
     AtlasSprite::register_schema();
 }
diff --git a/framework_crates/bones_framework/src/render/ui.rs b/framework_crates/bones_framework/src/render/ui.rs
index d47dd770e8..a0f553099e 100644
--- a/framework_crates/bones_framework/src/render/ui.rs
+++ b/framework_crates/bones_framework/src/render/ui.rs
@@ -10,7 +10,7 @@ use serde::Deserialize;
 pub mod widgets;
 
 /// The Bones Framework UI plugin.
-pub fn ui_plugin(_session: &mut SessionBuilder) {
+pub fn ui_plugin(_session: &mut Session) {
     // TODO: remove this plugin if it remains unused.
 }
 
diff --git a/framework_crates/bones_framework/tests/reset.rs b/framework_crates/bones_framework/tests/reset.rs
index 428bd6f382..88e6affb59 100644
--- a/framework_crates/bones_framework/tests/reset.rs
+++ b/framework_crates/bones_framework/tests/reset.rs
@@ -12,11 +12,10 @@ pub fn startup_system_reset() {
 
     // Session startup increments counter by 1
     game.sessions
-        .create_with("game", |builder: &mut SessionBuilder| {
-            builder.add_system_to_stage(Startup, |mut counter: ResMut<Counter>| {
-                // Increment to 1
-                counter.0 += 1;
-            });
+        .create("game")
+        .add_system_to_stage(Startup, |mut counter: ResMut<Counter>| {
+            // Increment to 1
+            counter.0 += 1;
         });
 
     // Step twice, startup system should only run once
@@ -28,11 +27,8 @@ pub fn startup_system_reset() {
 
     // Reset the world; Equivalent to reseting at the start or end of the frame.
     // `StartupSystemsRan` is inserted into the world to indicate completion,
-    // but is not retained so startup systems should run again.
-    {
-        let world = &game.sessions.get_mut("game").unwrap().world;
-        world.resource_mut::<ResetWorld>().reset_world(world);
-    }
+    // but is not kept so startup systems should run again.
+    ResetWorld::standard().reset(&game.sessions.get_mut("game").unwrap().world);
 
     // step again to trigger startup
     game.step(Instant::now());
@@ -48,25 +44,24 @@ pub fn single_success_system_reset() {
     let mut game = Game::new();
 
     game.sessions
-        .create_with("game", |builder: &mut SessionBuilder| {
-            // Counter should not be retained on reset.
-            builder.add_system_to_stage(Startup, |world: &World| {
-                world.insert_resource(Counter(0));
-            });
-            // Single success system increments counter by 1 until 2.
-            builder.add_system_to_stage(
-                First,
-                single_success_system(Ulid::new(), |mut counter: ResMut<Counter>| -> Option<()> {
-                    // Increment until 2
-                    counter.0 += 1;
-                    if counter.0 >= 2 {
-                        return Some(());
-                    }
-
-                    None
-                }),
-            );
-        });
+        .create_with("game")
+        // Counter should not be kept on reset.
+        .add_system_to_stage(Startup, |world: &World| {
+            world.insert_resource(Counter(0));
+        })
+        // Single success system increments counter by 1 until 2.
+        .add_system_to_stage(
+            First,
+            single_success_system(Ulid::new(), |mut counter: ResMut<Counter>| -> Option<()> {
+                // Increment until 2
+                counter.0 += 1;
+                if counter.0 >= 2 {
+                    return Some(());
+                }
+
+                None
+            }),
+        );
 
     // Step three times, single success should've incremented counter to 2 and completed.
     game.step(Instant::now());
@@ -81,10 +76,7 @@ pub fn single_success_system_reset() {
     }
 
     // Reset the world; Equivalent to reseting at the start or end of the frame.
-    {
-        let world = &game.sessions.get_mut("game").unwrap().world;
-        world.resource_mut::<ResetWorld>().reset_world(world);
-    }
+    ResetWorld::standard().reset(&game.sessions.get_mut("game").unwrap().world);
 
     // Counter & SingleSuccessSystems should not exist now.
     {
@@ -130,80 +122,69 @@ pub fn single_success_system_reset() {
 }
 
 #[test]
-pub fn reset_world_resource_retain() {
+pub fn reset_world_resource_keep_and_drop() {
     let mut game = Game::new();
 
-    // insert counter resource
     game.sessions
-        .create_with("game", |builder: &mut SessionBuilder| {
-            // This will put the resource into `ResetWorld`'s retained resources
-            // when built.
-            builder.insert_resource(Counter(2));
-            // Insert unit type on startup that won't be retained on reset.
-            builder.add_system_to_stage(Startup, |world: &World| {
-                world.insert_resource(());
-            });
-        });
+        .create("game")
+        // This will add the counter resource to the startup stage.
+        .add_startup_resource(Counter(2))
+        // Same here only with the default bool; we won't keep this one.
+        .init_startup_resource::<bool>();
 
     game.step(Instant::now());
 
-    // assert Counter is still 2 & unit resource exists
+    // assert that the resources were inserted on startup
     {
         let world = &game.sessions.get("game").unwrap().world;
+
         let counter = world.get_resource::<Counter>().unwrap();
         assert_eq!(counter.0, 2);
-        let unit = world.get_resource::<()>();
-        assert!(unit.is_some());
+
+        let boolean = world.get_resource::<bool>().unwrap();
+        assert!(boolean == false); // false is boolean default
     }
 
-    // Reset the world; Equivalent to reseting at the start or end of the frame.
-    // Counter should be retained since `SessionBuilder` inserts "startup
-    // resources" into `ResetWorld` when the session is built.
-    // Unit type was inserted in the Startup stage so should not be retained.
+    // keep resources & reset world
     {
         let world = &game.sessions.get_mut("game").unwrap().world;
-        world.resource_mut::<ResetWorld>().reset_world(world);
+
+        // Mutate resources to check if replaced on startup later.
+        world.resource_mut::<Counter>().0 = 3;
+        *world.resource_mut::<bool>() = true;
+
+        ResetWorld::standard()
+            // Retain the counter resource, but not the boolean resource.
+            .keep::<Counter>()
+            // Reset the world; Equivalent to reseting at the start or end of the
+            // frame here.
+            .reset(world);
     }
 
-    // Verify that Counter is still 2, instead of being removed.
-    // Verify counter is removed.
+    // verify Counter is 3 and boolean type is gone
     {
         let world = &game.sessions.get("game").unwrap().world;
-        let counter = world.get_resource::<Counter>().unwrap();
-        assert_eq!(counter.0, 2);
-        let unit = world.get_resource::<()>();
-        assert!(unit.is_none());
-    }
-}
 
-#[test]
-pub fn reset_world_resource_drop() {
-    let mut game = Game::new();
+        let counter = world.get_resource::<Counter>().unwrap();
+        assert_eq!(counter.0, 3);
 
-    // insert counter resource
-    game.sessions
-        .create_with("game", |builder: &mut SessionBuilder| {
-            // This will put the resource into `ResetWorld`'s retained resources
-            // when built.
-            builder.insert_resource(Counter(2));
-        });
+        let boolean = world.get_resource::<bool>();
+        assert!(boolean.is_none());
+    }
 
+    // step the game and make sure the startup resource systems don't replace
+    // Counter; we never want to replace kept resources on startup otherwise
+    // they wouldn't be useful.
     game.step(Instant::now());
 
-    // there are no systems but assert Counter is still 2
-    {
-        let session = game.sessions.get("game").unwrap();
-        let counter = session.world.get_resource::<Counter>().unwrap();
-        assert_eq!(counter.0, 2);
-    }
-    // Reset the world; Equivalent to reseting at the start or end of the frame.
-    // Remove Counter from `ResetWorld`; It should not exist after the call.
     {
-        let world = &game.sessions.get_mut("game").unwrap().world;
-        let mut reset = world.resource_mut::<ResetWorld>();
-        reset.drop_resource::<Counter>();
-        reset.reset_world(world);
+        let world = &game.sessions.get("game").unwrap().world;
+
+        let counter = world.get_resource::<Counter>().unwrap();
+        assert_eq!(counter.0, 3);
 
-        assert!(world.get_resource::<Counter>().is_none());
+        // boolean should be re-inserted on startup but at the default value
+        let boolean = world.get_resource::<bool>().unwrap();
+        assert!(boolean == false);
     }
 }
diff --git a/framework_crates/bones_lib/src/lib.rs b/framework_crates/bones_lib/src/lib.rs
index 498bb74372..0218440aaa 100644
--- a/framework_crates/bones_lib/src/lib.rs
+++ b/framework_crates/bones_lib/src/lib.rs
@@ -11,9 +11,8 @@ pub use bones_ecs as ecs;
 /// Bones lib prelude
 pub mod prelude {
     pub use crate::{
-        ecs::prelude::*, instant::Instant, reset::*, single_success_system, time::*, Game,
-        GamePlugin, Session, SessionBuilder, SessionCommand, SessionOptions, SessionPlugin,
-        SessionRunner, Sessions, SingleSuccessSystems, StartupResources,
+        ecs::prelude::*, instant::Instant, reset::*, time::*, Game, GamePlugin, Session,
+        SessionCommand, SessionOptions, SessionPlugin, SessionRunner, Sessions,
     };
     pub use ustr::{ustr, Ustr, UstrMap, UstrSet};
 }
@@ -27,16 +26,16 @@ use tracing::warn;
 
 use crate::prelude::*;
 
-/// Builder type used to create [`Session`]. If using this directly (as opposed to [`Sessions::create_with`]),
-/// it is important to rember to finish session and add to [`Sessions`] with [`SessionBuilder::finish_and_add`].
-pub struct SessionBuilder {
-    /// Name of session
-    pub name: Ustr,
-    /// System stage builder
-    pub stages: SystemStagesBuilder,
-    /// Resources to be inserted into the world when finished building. Inserted
-    /// collectively into the world as the [`StartupResources`] resource.
-    pub startup_resources: UntypedResourceSet,
+/// Contains a bones [`World`] for state, [`SystemStages`] for behavior, and a
+/// [`SessionRunner`] to determine how those are used.
+#[non_exhaustive]
+#[derive(Deref, DerefMut)]
+pub struct Session {
+    /// The ECS world for the core.
+    pub world: World,
+    /// The system stages.
+    #[deref]
+    pub stages: SystemStages,
     /// Whether or not this session should have it's systems run.
     pub active: bool,
     /// Whether or not this session should be rendered.
@@ -45,303 +44,27 @@ pub struct SessionBuilder {
     pub priority: i32,
     /// The session runner to use for this session.
     pub runner: Box<dyn SessionRunner>,
-
-    /// Tracks if builder has been finished, and warn on drop if not finished.
-    finish_guard: FinishGuard,
 }
 
-impl SessionBuilder {
-    /// Create a new [`SessionBuilder`]. Be sure to add it to [`Sessions`] when finished, with [`SessionBuilder::finish_and_add`], or [`Sessions::create`].
-    ///
-    /// # Panics
-    ///
-    /// Panics if the `name.try_into()` cannot convert into [`Ustr`].
-    pub fn new<N: TryInto<Ustr>>(name: N) -> Self
-    where
-        <N as TryInto<Ustr>>::Error: Debug,
-    {
-        let name = name
-            .try_into()
-            .expect("Session name could not be converted into Ustr.");
+impl Default for Session {
+    fn default() -> Self {
         Self {
-            name,
+            world: World::default(),
             stages: default(),
-            startup_resources: default(),
             active: true,
             visible: true,
             priority: 0,
             runner: Box::new(DefaultSessionRunner),
-            finish_guard: FinishGuard { finished: false },
-        }
-    }
-
-    /// Create a [`SessionBuilder`] to match existing [`Session`], consuming it. This is useful if a [`GamePlugin`] wishes to modify a session created by another plugin.
-    /// The builder is initialized with settings from session, can be further modified, and then added to session to replace existing.
-    pub fn from_existing_session<N: TryInto<Ustr>>(name: N, session: Session) -> Self
-    where
-        <N as TryInto<Ustr>>::Error: Debug,
-    {
-        let name = name
-            .try_into()
-            .expect("Session name could not be converted into Ustr.");
-
-        Self {
-            name,
-            stages: SystemStagesBuilder::from_stages(session.stages),
-            startup_resources: session
-                .world
-                .resources
-                .remove::<StartupResources>()
-                .unwrap_or_default()
-                .0,
-            active: session.active,
-            visible: session.visible,
-            priority: session.priority,
-            runner: session.runner,
-            finish_guard: FinishGuard { finished: false },
         }
     }
+}
 
-    /// Get the [`SystemStagesBuilder`] (though the stage build functions are also on [`SessionBuilder`] for convenience).
-    pub fn stages(&mut self) -> &mut SystemStagesBuilder {
-        &mut self.stages
-    }
-
-    /// Whether or not session should run systems.
-    pub fn set_active(&mut self, active: bool) -> &mut Self {
-        self.active = active;
-        self
-    }
-
-    /// Whether or not session should be rendered.
-    pub fn set_visible(&mut self, visible: bool) -> &mut Self {
-        self.visible = visible;
-        self
-    }
-
-    /// The priority of this session relative to other sessions in the [`Game`].
-    pub fn set_priority(&mut self, priority: i32) -> &mut Self {
-        self.priority = priority;
-        self
-    }
-
-    /// Insert a resource.
-    ///
-    /// Note: The resource is not actually initialized in World until first step of [`SystemStages`].
-    /// To mutate or inspect a resource inserted by another [`SessionPlugin`] during session build, use [`SessionBuilder::resource_mut`].
-    pub fn insert_resource<T: HasSchema>(&mut self, resource: T) -> &mut Self {
-        self.startup_resources.insert_resource(resource);
-        self
-    }
-
-    /// Insert a resource using default value (if not found). Returns a mutable ref for modification.
-    ///
-    /// Note: The resource is not actually initialized in World until first step of [`SystemStages`].
-    /// To mutate or inspect a resource inserted by another [`SessionPlugin`] during session build, use [`SessionBuilder::resource_mut`].
-    pub fn init_resource<T: HasSchema + Default>(&mut self) -> RefMut<'_, T> {
-        self.startup_resources.init_resource::<T>()
-    }
-
-    /// Get mutable reference to a resource if it exists.
-    pub fn resource_mut<T: HasSchema>(&self) -> Option<RefMut<'_, T>> {
-        self.startup_resources.resource_mut::<T>()
-    }
-
-    /// Add a system to the [`CoreStage::Startup`] stage which specially runs
-    /// only once, before all other core stages. Inserting [`StartupSystemsRan`]
-    /// into the world prevents systems in the startup stage from running.
-    #[deprecated = "use `add_system_to_stage(CoreStage::Startup, your_system)` instead"]
-    pub fn add_startup_system<Args, S>(&mut self, system: S) -> &mut Self
-    where
-        S: IntoSystem<Args, (), (), Sys = StaticSystem<(), ()>>,
-    {
-        self.stages
-            .add_system_to_stage(CoreStage::Startup, system.system());
-        self
-    }
-
-    /// Convenience method. Adds a system that will run each frame until it succeeds (returns Some).
-    /// Uses Option to allow for easy usage of `?`. System is added to
-    /// [`CoreStage::First`].
-    ///
-    /// See also the wrapper function used inside [`single_success_system`].
-    #[deprecated = "use `.add_system_to_stage(First, single_success_system(Ulid::new(), your_system)"]
-    pub fn add_single_success_system<Args, S>(&mut self, system: S) -> &mut Self
-    where
-        S: IntoSystem<Args, (), Option<()>, Sys = StaticSystem<(), Option<()>>>,
-    {
-        self.stages
-            .add_system_to_stage(First, single_success_system(Ulid::new(), system));
-        self
-    }
-
-    /// Add a [`System`] to the stage with the given label.
-    pub fn add_system_to_stage<Args, S>(&mut self, label: impl StageLabel, system: S) -> &mut Self
-    where
-        S: IntoSystem<Args, (), (), Sys = StaticSystem<(), ()>>,
-    {
-        self.stages.add_system_to_stage(label, system);
-        self
-    }
-
-    /// Insert a new stage, before another existing stage
-    pub fn insert_stage_before<L: StageLabel, S: SystemStage + 'static>(
-        &mut self,
-        label: L,
-        stage: S,
-    ) -> &mut SessionBuilder {
-        self.stages.insert_stage_before(label, stage);
-        self
-    }
-
-    /// Insert a new stage, after another existing stage
-    pub fn insert_stage_after<L: StageLabel, S: SystemStage + 'static>(
-        &mut self,
-        label: L,
-        stage: S,
-    ) -> &mut SessionBuilder {
-        self.stages.insert_stage_after(label, stage);
-
-        self
-    }
-
-    /// Set the session runner for this session.
-    pub fn set_session_runner(&mut self, runner: Box<dyn SessionRunner>) {
-        self.runner = runner;
-    }
-
+impl Session {
     /// Install a plugin.
     pub fn install_plugin(&mut self, plugin: impl SessionPlugin) -> &mut Self {
         plugin.install(self);
         self
     }
-
-    /// Finalize and add to [`Sessions`].
-    ///
-    /// Alternatively, you may directly pass a [`SessionBuilder`] to [`Sessions::create`] to add and finalize.
-    pub fn finish_and_add(mut self, sessions: &mut Sessions) -> &mut Session {
-        let mut session = Session {
-            world: {
-                let w = World::default();
-                w.init_resource::<Time>();
-                {
-                    let mut reset = w.init_resource::<ResetWorld>();
-                    for untyped in self.startup_resources.resources() {
-                        reset.reset_resources.insert(untyped.schema().id());
-                    }
-                }
-                w
-            },
-            stages: self.stages.finish(),
-            active: self.active,
-            visible: self.visible,
-            priority: self.priority,
-            runner: self.runner,
-        };
-
-        // mark guard as finished to avoid warning on drop of SessionBuilder.
-        self.finish_guard.finished = true;
-
-        // Insert startup resources so if other sessions look for them, they are present.
-        self.startup_resources
-            .insert_on_world(&mut session.world, true);
-        session
-            .world
-            .insert_resource(StartupResources(self.startup_resources));
-
-        sessions.add(self.name, session)
-    }
-}
-
-/// This is currently just used for letting you create a [`SessionBuilder`] from
-/// a session.
-#[derive(HasSchema, Clone, Default, Deref, DerefMut)]
-pub struct StartupResources(pub UntypedResourceSet);
-
-/// Guard for [`SessionBuilder` ensuring we warn if it goes out of scope without being finished and added to [`Sessions`].
-struct FinishGuard {
-    pub finished: bool,
-}
-
-impl Drop for FinishGuard {
-    fn drop(&mut self) {
-        if !self.finished {
-            warn!("`SessionBuilder` went out of scope. This may have been an acccident in building Session.
-                        `finish` the session builder, or directly add to Game's `Sessions` to ensure is created and saved.")
-        }
-    }
-}
-
-/// Wrapper system for single success systems.
-///
-/// Runs the given system each frame until it succeeds (returns Some). Uses
-/// `Option<()>` instead of a `bool` to allow for easy usage of `?`.
-///
-/// Takes a [`Ulid`] that is used to identify whether or not the system has
-/// succeeded from the [`SingleSuccessSystems`] resource.
-pub fn single_success_system<Args, S>(id: Ulid, system: S) -> StaticSystem<(), ()>
-where
-    S: IntoSystem<Args, (), Option<()>, Sys = StaticSystem<(), Option<()>>>,
-{
-    let mut system = system.system();
-    (move |world: &World| {
-        let succeeded = world
-            .init_resource::<SingleSuccessSystems>()
-            .has_system_succeeded(id);
-        if !succeeded && system.run(world, ()).is_some() {
-            world
-                .init_resource::<SingleSuccessSystems>()
-                .set_system_completed(id);
-        }
-    })
-    .system()
-}
-
-/// Resource tracking which of single success systems have completed with a
-/// [`HashSet`] of [`Ulid`] for the succeeded.
-#[derive(HasSchema, Clone, Default, Deref, DerefMut)]
-pub struct SingleSuccessSystems(pub HashSet<Ulid>);
-
-impl SingleSuccessSystems {
-    /// Reset single success systems completion status. so they run again until success.
-    #[inline]
-    pub fn reset(&mut self) {
-        self.clear();
-    }
-
-    /// Check if system has completed
-    #[inline]
-    pub fn has_system_succeeded(&self, ulid: Ulid) -> bool {
-        self.contains(&ulid)
-    }
-
-    /// Mark system as completed.
-    #[inline]
-    pub fn set_system_completed(&mut self, ulid: Ulid) {
-        self.insert(ulid);
-    }
-}
-
-/// A bones game. This includes all of the game worlds, and systems.
-///
-/// [`Session`] is not allowed to be constructed directly.
-/// See [`Sessions::create`] or [`SessionBuilder`] for creating a new `Session`.
-#[non_exhaustive]
-#[derive(Deref, DerefMut)]
-pub struct Session {
-    /// The ECS world for the core.
-    pub world: World,
-    /// The system stages.
-    #[deref]
-    pub stages: SystemStages,
-    /// Whether or not this session should have it's systems run.
-    pub active: bool,
-    /// Whether or not this session should be rendered.
-    pub visible: bool,
-    /// The priority of this session relative to other sessions in the [`Game`].
-    pub priority: i32,
-    /// The session runner to use for this session.
-    pub runner: Box<dyn SessionRunner>,
 }
 
 impl std::fmt::Debug for Session {
@@ -357,37 +80,13 @@ impl std::fmt::Debug for Session {
     }
 }
 
-impl Session {
-    /// Snapshot the world state.
-    ///
-    /// This is the same as `core.world.clone()`, but it is more explicit.
-    pub fn snapshot(&self) -> World {
-        self.world.clone()
-    }
-
-    /// Restore the world state.
-    ///
-    /// Re-sets the world state to that of the provided `world`, which may or may not have been
-    /// created with [`snapshot()`][Self::snapshot].
-    ///
-    /// This is the same as doing an [`std::mem::swap`] on `self.world`, but it is more explicit.
-    pub fn restore(&mut self, world: &mut World) {
-        std::mem::swap(&mut self.world, world)
-    }
-
-    /// Set the session runner for this session.
-    pub fn set_session_runner(&mut self, runner: Box<dyn SessionRunner>) {
-        self.runner = runner;
-    }
-}
-
 /// Trait for plugins that can be installed into a [`Session`].
 pub trait SessionPlugin {
     /// Install the plugin into the [`Session`].
-    fn install(self, session: &mut SessionBuilder);
+    fn install(self, session: &mut Session);
 }
-impl<F: FnOnce(&mut SessionBuilder)> SessionPlugin for F {
-    fn install(self, session: &mut SessionBuilder) {
+impl<F: FnOnce(&mut Session)> SessionPlugin for F {
+    fn install(self, session: &mut Session) {
         (self)(session)
     }
 }
@@ -419,11 +118,6 @@ pub trait SessionRunner: Sync + Send + 'static {
     /// fn step(&mut self, now: Instant, world: &mut World, stages: &mut SystemStages) {
     ///     world.resource_mut::<Time>().update_with_instant(now);
     ///     stages.run(world);
-    ///
-    ///     // Not required for runner - but calling this allows [`ResetWorld`] resource to
-    ///     // reset world state from gameplay.
-    ///     world.handle_world_reset();
-    ///
     /// }
     /// fn restart_session(&mut self) {}
     /// fn disable_local_input(&mut self, disable_input: bool) {}
@@ -446,7 +140,7 @@ pub trait SessionRunner: Sync + Send + 'static {
 pub struct DefaultSessionRunner;
 impl SessionRunner for DefaultSessionRunner {
     fn step(&mut self, now: instant::Instant, world: &mut World, stages: &mut SystemStages) {
-        world.resource_mut::<Time>().update_with_instant(now);
+        world.init_resource::<Time>().update_with_instant(now);
         stages.run(world);
     }
 
@@ -881,50 +575,35 @@ pub struct SessionOptions {
 }
 
 impl Sessions {
-    /// Create a new session from [`SessionBuilder`], insert into [`Sessions`], and borrow it mutably so it can be modified.
-    /// If session with same name already exists, it will be replaced.
-    pub fn create(&mut self, builder: SessionBuilder) -> &mut Session {
-        builder.finish_and_add(self)
-    }
-
-    /// Create a new session from default [`SessionBuilder`], and modify in closure before it is added to [`Sessions`]. Then borrow it mutably so it can be modified.
-    ///
-    /// If session with same name already exists, it will be replaced.
-    pub fn create_with<N: TryInto<Ustr>>(
-        &mut self,
-        name: N,
-        plugin: impl SessionPlugin,
-    ) -> &mut Session
+    /// Create a new session, and borrow it mutably so it can be modified.
+    #[track_caller]
+    pub fn create<K: TryInto<Ustr>>(&mut self, name: K) -> &mut Session
     where
-        <N as TryInto<Ustr>>::Error: Debug,
+        <K as TryInto<Ustr>>::Error: Debug,
     {
-        let mut builder = SessionBuilder::new(name);
-        builder.install_plugin(plugin);
-        builder.finish_and_add(self)
+        let name = name.try_into().unwrap();
+        // Create a blank session
+        let session = Session::default();
+
+        // Insert it into the map
+        self.map.insert(name, session);
+
+        // And borrow it for the modification
+        self.map.get_mut(&name).unwrap()
     }
 
-    /// Replaces an existing session after converting it into a [`SessionBuilder`] with same systems, stages, etc. It then is given to `build_function` to extend or modify it.
-    ///
-    /// WARNING - this is intended to allow a [`GamePlugin`] to extend a session created by another plugin during setup. It destroys and re-creates session, and if used during gameplay,
-    /// could break assumptions around determinism and cause desyncs in network play. The sessions [`World`] is not preserved. This is a utility for constructing session, not for runtime mutation.
-    ///
-    /// `None` is returned if the session with name was not found.
-    pub fn modify_and_replace_existing_session<N: TryInto<Ustr>>(
+    /// Create a new session, and borrow it mutably so it can be modified.
+    #[track_caller]
+    pub fn create_with<K: TryInto<Ustr>>(
         &mut self,
-        name: N,
-        build_function: impl FnOnce(&mut SessionBuilder),
-    ) -> Option<&mut Session>
+        name: K,
+        plugin: impl SessionPlugin,
+    ) -> &mut Session
     where
-        <N as TryInto<Ustr>>::Error: Debug,
+        <K as TryInto<Ustr>>::Error: Debug,
     {
-        let name = name
-            .try_into()
-            .expect("Session name could not be converted into Ustr.");
-
-        let session = self.map.remove(&name)?;
-        let mut builder = SessionBuilder::from_existing_session(name, session);
-        build_function(&mut builder);
-        Some(builder.finish_and_add(self))
+        let session = self.create(name);
+        session.install_plugin(plugin)
     }
 
     /// Delete a session.
@@ -968,16 +647,4 @@ impl Sessions {
     pub fn add_command(&mut self, command: Box<SessionCommand>) {
         self.commands.push_back(command);
     }
-
-    /// Add a [`Session`] to [`Sessions`]. This function is private, used by [`SessionBuilder`] to save the finished `Session`,
-    /// and is not directly useful to user as a `Session` may not be directly constructed.
-    ///
-    /// To build a new session, see [`Sessions::create`] or [`Sessions::create_with`].
-    fn add(&mut self, name: Ustr, session: Session) -> &mut Session {
-        // Insert it into the map
-        self.map.insert(name, session);
-
-        // And borrow it for the modification
-        self.map.get_mut(&name).unwrap()
-    }
 }
diff --git a/framework_crates/bones_lib/src/reset.rs b/framework_crates/bones_lib/src/reset.rs
index 7a008503f0..9e20fe3f30 100644
--- a/framework_crates/bones_lib/src/reset.rs
+++ b/framework_crates/bones_lib/src/reset.rs
@@ -1,54 +1,69 @@
-//! Conveniences for resetting a World to its' startup state.
+//! Conveniences for resetting a World to its' default state.
 use crate::prelude::*;
 
-/// Convenience resource for reseting the [`World`] while retaining a selection of resources if desired.
+/// Convenience type for selecting resources to keep before clearing the
+/// components, entities, and resources on a [`World`].
+///  ```ignore
+/// ResetWorld::standard()
+///     .keep::<Scoreboard>()
+///     .keep::<WritingRust>()
+///     .keep::<TheBugsAway>()
+///     .reset(world);
+/// ```
+/// Reseting the world should likely be the first call in your systems when
+/// applicable so that components are rendered continuously without disappearing
+/// for a frame before respawning world startup components.
 ///
-/// See [`Self::reset_world`]
-#[derive(HasSchema, Clone, Default)]
-pub struct ResetWorld {
-    /// Set of [`SchemaId`]s for the resources that will not be removed from the
-    /// world when calling [`Self::reset_world`].
-    pub reset_resources: HashSet<SchemaId>,
-}
+/// You can create the type with [`Self::standard`], which is recommended for
+/// keeping certain special resources like [`SessionOptions`] & [`Entities`] on
+/// creation, or you can use [`Self::empty`] to create a new type that won't
+/// keep any resources on creation.
+///
+/// To add more resources to the list you can use [`self.keep`](Self::keep) with
+/// the specified type, no data needed, and chain the methods like the example
+/// above.
+///
+/// Uses a [`HashSet`] of [`SchemaId`] to determine the resources that will not
+/// be removed from the world on reset.
+#[derive(HasSchema, Default, Clone, Deref, DerefMut)]
+pub struct ResetWorld(pub HashSet<SchemaId>);
 
 impl ResetWorld {
-    /// Adds the [`SchemaId`] of the type given to the set of resources to
-    /// retain on reset.
-    pub fn retain_resource<T: HasSchema>(&mut self) {
-        self.reset_resources.insert(T::schema().id());
+    /// Create a [`ResetWorld`] with no resources kept as opposed to the
+    /// [`Self::standard`] which keeps certain special resources on creation.
+    pub fn empty() -> Self {
+        Self(HashSet::default())
     }
-
-    /// Removes the [`SchemaId`] of the type given from the set of resources to
-    /// retain on reset.
-    pub fn drop_resource<T: HasSchema>(&mut self) {
-        self.reset_resources.remove(&T::schema().id());
+    /// Create a [`ResetWorld`] that already keeps some basic special resources
+    /// that are usually needed like [`SessionOptions`] & [`Entities`].
+    pub fn standard() -> Self {
+        Self::empty().keep::<Entities>().keep::<SessionOptions>()
     }
-
-    /// Convenience method for reseting the [`World`]. Clears components,
-    /// entities, and resources out of the world.
-    ///
-    /// Resources in [`self.reset_resources`](Self::reset_resources) field are
-    /// not removed from the world and can be easily added via
-    /// [`Self::retain_resource`] or removed via [`Self::drop_resource`].
+    /// Adds the [`SchemaId`] of the type given to the set of resources to keep
+    /// on reset.
     ///
-    /// [`Entities`], [`Time`], [`SessionOptions`], and [`ResetWorld`] are
-    /// always retained when calling.
-    ///
-    /// This should likely be the first call in your systems so that components
-    /// are rendered continuously without dropping out for one frame before
-    /// respawning world startup components.
-    ///
-    /// Safe to call while borrowing `Self` as a resource from the world without
-    /// panicking.
-    pub fn reset_world(&mut self, world: &World) {
-        self.retain_resource::<ResetWorld>(); // This prevents a mutable borrow in `retain_owned_resources`.
-        self.retain_resource::<Entities>();
-        self.retain_resource::<Time>(); // TODO: make sure we need the `Time` resource retained.
-        self.retain_resource::<SessionOptions>();
-
+    /// Returns `Self` to allow chaining the method:
+    /// ```ignore
+    /// Self::standard()
+    ///     .keep::<Scoreboard>()
+    ///     .keep::<WritingRust>()
+    ///     .keep::<TheBugsAway>()
+    ///     .reset(world);
+    /// ```
+    pub fn keep<T: HasSchema>(mut self) -> Self {
+        self.insert(T::schema().id());
+        self
+    }
+    /// Reset the given [`World`], clearing resources that are not included in
+    /// `self` as well as components and entities.
+    pub fn reset(self, world: &World) {
         world.resource_mut::<Entities>().kill_all(); // `kill_all` for component clearing
         world.maintain(); // clear components
         *world.resource_mut::<Entities>() = Entities::default(); // fully reset entities
-        world.retain_owned_resources(|schema_id| self.reset_resources.contains(&schema_id));
+        world.retain_owned_resources(|schema_id| self.contains(&schema_id));
+    }
+    /// Reset the given [`World`]'s resources that are not included in `self`.
+    pub fn reset_resources(self, world: &World) {
+        world.retain_owned_resources(|schema_id| self.contains(&schema_id));
     }
 }
diff --git a/framework_crates/bones_scripting/src/lua.rs b/framework_crates/bones_scripting/src/lua.rs
index b306120982..a947bb6a12 100644
--- a/framework_crates/bones_scripting/src/lua.rs
+++ b/framework_crates/bones_scripting/src/lua.rs
@@ -47,8 +47,8 @@ pub struct LuaPluginLoaderSessionPlugin(pub Arc<Vec<Handle<LuaPlugin>>>);
 pub struct LuaPlugins(pub Arc<Vec<Handle<LuaPlugin>>>);
 
 impl SessionPlugin for LuaPluginLoaderSessionPlugin {
-    fn install(self, session: &mut SessionBuilder) {
-        session.insert_resource(LuaPlugins(self.0));
+    fn install(self, session: &mut Session) {
+        session.add_startup_resource(LuaPlugins(self.0));
 
         for lua_stage in [
             CoreStage::Startup,

From b5dd6fcd510c39410e83d0a56ed5f1c4b983f010 Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Sun, 17 May 2026 13:05:28 -0500
Subject: [PATCH 16/36] chore: remove CurrentSystemStage It is possible it
 could have use in the future but is unlikely. Simplicity is more important
 and we can still add this if needed later.

---
 framework_crates/bones_ecs/src/stage.rs | 15 ---------------
 1 file changed, 15 deletions(-)

diff --git a/framework_crates/bones_ecs/src/stage.rs b/framework_crates/bones_ecs/src/stage.rs
index 24b6f0cf53..7774dbe086 100644
--- a/framework_crates/bones_ecs/src/stage.rs
+++ b/framework_crates/bones_ecs/src/stage.rs
@@ -4,12 +4,6 @@ use std::collections::VecDeque;
 
 use crate::prelude::*;
 
-/// Resource that is automatically added to the world while a system stage is being run
-/// that specifies the unique ID of the stage that being run.
-// TODO: remove this resource if unused.
-#[derive(Deref, DerefMut, Clone, Copy, HasSchema, Default)]
-pub struct CurrentSystemStage(pub Ulid);
-
 /// An ordered collection of [`SystemStage`]s.
 pub struct SystemStages {
     /// The stages in the collection, in the order that they will be run.
@@ -97,20 +91,11 @@ impl SystemStages {
 
     /// Execute the systems on the given `world`.
     pub fn run(&mut self, world: &mut World) {
-        // Run each stage
         for stage in &mut self.stages {
-            // Set the current stage resource
-            world.insert_resource(CurrentSystemStage(stage.id()));
-
-            // Run the stage
             stage.run(world);
         }
-
         // Cleanup killed entities
         world.maintain();
-
-        // Remove the current system stage resource
-        world.resources.remove::<CurrentSystemStage>();
     }
 
     /// Add a system to the [`CoreStage::Startup`] stage which specially runs

From d1bc43155082d63271d5c9974e2cb40852c1487e Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Fri, 29 May 2026 08:46:51 -0500
Subject: [PATCH 17/36] feat: add serde ser & de to GamepadAxis, GamepadButton,
 and KeyCode

---
 .../bones_framework/src/input/gamepad.rs        | 17 +++++++++++++++--
 .../bones_framework/src/input/keyboard.rs       | 13 ++++++++++++-
 2 files changed, 27 insertions(+), 3 deletions(-)

diff --git a/framework_crates/bones_framework/src/input/gamepad.rs b/framework_crates/bones_framework/src/input/gamepad.rs
index 399ce61405..37639ec5d4 100644
--- a/framework_crates/bones_framework/src/input/gamepad.rs
+++ b/framework_crates/bones_framework/src/input/gamepad.rs
@@ -64,7 +64,18 @@ pub struct GamepadButtonEvent {
 
 /// A specific button on a gamepad.
 #[allow(missing_docs)]
-#[derive(HasSchema, Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
+#[derive(
+    HasSchema,
+    Clone,
+    Copy,
+    Debug,
+    Default,
+    PartialEq,
+    Eq,
+    Hash,
+    serde::Deserialize,
+    serde::Serialize,
+)]
 #[repr(C, u8)]
 pub enum GamepadButton {
     #[default]
@@ -135,7 +146,9 @@ pub struct GamepadAxisEvent {
 }
 
 /// A specific gamepad axis that may have changed.
-#[derive(HasSchema, Clone, Copy, Debug, PartialEq, Eq, Hash)]
+#[derive(
+    HasSchema, Clone, Copy, Debug, PartialEq, Eq, Hash, serde::Deserialize, serde::Serialize,
+)]
 #[schema(no_default)]
 #[allow(missing_docs)]
 #[repr(C, u8)]
diff --git a/framework_crates/bones_framework/src/input/keyboard.rs b/framework_crates/bones_framework/src/input/keyboard.rs
index 6e055f193e..246644d244 100644
--- a/framework_crates/bones_framework/src/input/keyboard.rs
+++ b/framework_crates/bones_framework/src/input/keyboard.rs
@@ -23,7 +23,18 @@ pub struct KeyboardEvent {
 }
 
 /// The key code of a keyboard key.
-#[derive(HasSchema, Clone, Copy, Default, Debug, PartialEq, Eq, Hash)]
+#[derive(
+    HasSchema,
+    Clone,
+    Copy,
+    Default,
+    Debug,
+    PartialEq,
+    Eq,
+    Hash,
+    serde::Deserialize,
+    serde::Serialize,
+)]
 #[repr(u32)]
 pub enum KeyCode {
     #[default]

From eb34856c001a07421f5571a238bac6221861fe4b Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Fri, 29 May 2026 10:57:38 -0500
Subject: [PATCH 18/36] doc: fix formatting

---
 framework_crates/bones_schema/macros/src/lib.rs | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/framework_crates/bones_schema/macros/src/lib.rs b/framework_crates/bones_schema/macros/src/lib.rs
index 95dd82f7f8..3eebbf2a33 100644
--- a/framework_crates/bones_schema/macros/src/lib.rs
+++ b/framework_crates/bones_schema/macros/src/lib.rs
@@ -15,22 +15,21 @@ macro_rules! throw {
 
 /// Derive macro for the HasSchema trait.
 ///
-/// ## Usage with #[repr(C)]
-/// HasSchema works with the #[repr(C)] annotation to fully implement its features.
+/// ## Usage with `#[repr(C)]`
+/// HasSchema works with the `#[repr(C)]` annotation to fully implement its features.
 ///
-/// If there is no #[repr(C)] annotation, the SchemaKind of your type's schema will be Opaque.
+/// If there is no `#[repr(C)]` annotation, the SchemaKind of your type's schema will be Opaque.
 ///
-/// This means if you don't know the kind of type, like in the case of a SchemaBox, you'll be unable
+/// This means if you don't know the kind of type, like in the case of a `SchemaBox`, you'll be unable
 /// to read the fields.
 ///
-/// This applies to bones' lua scripting since SchemaBox is effectively the "lua type".
-/// See SchemaBox.
+/// This applies to bones' lua scripting since `SchemaBox` is effectively the "lua type".
 ///
-/// If you intend a type to be opaque even though it has #[repr(C)] you can use #[schema(opaque)]
+/// If you intend a type to be opaque even though it has `#[repr(C)]` you can use `#[schema(opaque)]`
 /// to force an opaque schema representation.
 ///
-/// Keep in mind, enums deriving HasSchema with a #[repr(C)] annotation must also specify an
-/// enum tag type like #[repr(C, u8)] where u8 could be either u16 or u32 if you need
+/// Keep in mind, enums deriving HasSchema with a `#[repr(C)]` annotation must also specify an
+/// enum tag type like `#[repr(u8)]` where `u8` could be either `u16` or `u32` if you need
 /// more than 256 enum variants.
 ///
 /// ## no_default & no_clone attributes

From c3666dde83bead765471a40a1aaab26bc1b328d9 Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Mon, 1 Jun 2026 13:56:58 -0500
Subject: [PATCH 19/36] add Hash & Eq schema function opt-in derive macro
 attributes for HasSchema

---
 .../bones_schema/macros/src/lib.rs            | 92 ++++++++++++-------
 1 file changed, 61 insertions(+), 31 deletions(-)

diff --git a/framework_crates/bones_schema/macros/src/lib.rs b/framework_crates/bones_schema/macros/src/lib.rs
index 3eebbf2a33..1da2d43a58 100644
--- a/framework_crates/bones_schema/macros/src/lib.rs
+++ b/framework_crates/bones_schema/macros/src/lib.rs
@@ -16,26 +16,29 @@ macro_rules! throw {
 /// Derive macro for the HasSchema trait.
 ///
 /// ## Usage with `#[repr(C)]`
-/// HasSchema works with the `#[repr(C)]` annotation to fully implement its features.
+/// HasSchema works with the `#[repr(C)]` annotation to fully implement its
+/// features.
 ///
-/// If there is no `#[repr(C)]` annotation, the SchemaKind of your type's schema will be Opaque.
+/// If there is no `#[repr(C)]` annotation, the SchemaKind of your type's schema
+/// will be Opaque.
 ///
-/// This means if you don't know the kind of type, like in the case of a `SchemaBox`, you'll be unable
-/// to read the fields.
+/// This means if you don't know the kind of type, like in the case of a
+/// `SchemaBox`, you'll be unable to read the fields.
 ///
-/// This applies to bones' lua scripting since `SchemaBox` is effectively the "lua type".
+/// This applies to bones' lua scripting since `SchemaBox` is effectively the
+/// "lua type".
 ///
-/// If you intend a type to be opaque even though it has `#[repr(C)]` you can use `#[schema(opaque)]`
-/// to force an opaque schema representation.
+/// If you intend a type to be opaque even though it has `#[repr(C)]` you can
+/// use `#[schema(opaque)]` to force an opaque schema representation.
 ///
-/// Keep in mind, enums deriving HasSchema with a `#[repr(C)]` annotation must also specify an
-/// enum tag type like `#[repr(u8)]` where `u8` could be either `u16` or `u32` if you need
-/// more than 256 enum variants.
+/// Keep in mind, enums deriving HasSchema with a `#[repr(C)]` annotation must
+/// also specify an enum tag type like `#[repr(u8)]` where `u8` could be either
+/// `u16` or `u32` if you need more than 256 enum variants.
 ///
 /// ## no_default & no_clone attributes
-/// HasSchema derive requires the type to implement Default & Clone, if either of these cannot be
-/// implemented you can use the no_default & no_clone schema attributes respectively to ignore
-/// these requirements.
+/// HasSchema derive requires the type to implement Default & Clone, if either
+/// of these cannot be implemented you can use the no_default & no_clone schema
+/// attributes respectively to ignore these requirements.
 /// ```ignore
 /// #[derive(HasSchema, Default)]
 /// #[schema(no_clone)]
@@ -45,25 +48,40 @@ macro_rules! throw {
 /// #[schema(no_default)]
 /// struct DoesntImplDefault;
 /// ```
-/// The caveat for putting no_default on your type is that it cannot be created from a Schema.
-/// This is necessary if you want to create your type within a bones lua script.
+/// The caveat for putting no_default on your type is that it cannot be created
+/// from a Schema. This is necessary if you want to create your type within a
+/// bones lua script.
 ///
-/// Since the fields that need to be initialized to create a complete version of your type cannot be
-/// determined, Schema needs a default function to initialize the data properly.
+/// Since the fields that need to be initialized to create a complete version of
+/// your type cannot be determined, Schema needs a default function to
+/// initialize the data properly.
 ///
-/// The caveat for putting no_clone on your type is that it cannot be cloned in the form of a
-/// SchemaBox.
+/// The caveat for putting no_clone on your type is that it cannot be cloned in
+/// the form of a SchemaBox.
 ///
-/// This is critical in the case of bones' networking which will panic if your type is in the world
-/// and does not implement clone during the network rollback.
+/// This is critical in the case of bones' networking which will panic if your
+/// type is in the world and does not implement clone during the network
+/// rollback.
+///
+/// ## hash & eq attributes
+/// In order for a Schema to implement Hash and Eq, the derive requires opt in
+/// attributes instead of the opt out attributes required for Clone and Default
+/// since you are more likely to leave Hash and Eq out than you are to implement
+/// it.
+/// ```ignore
+/// #[derive(HasSchema, Clone, Default, PartialEq, Eq, Hash)]
+/// #[schema(hash, eq)]
+/// struct DoesImplHashAndEq;
+/// ```
 ///
 /// ## type_data attribute
-/// This attribute takes an expression and stores that value in what is basically
-/// a type keyed map accessible from your type's Schema.
+/// This attribute takes an expression and stores that value in what is
+/// basically a type keyed map accessible from your type's Schema.
 ///
 /// ## derive_type_data attribute
-/// This attribute is simply a shortcut equivalent to using the type_data attribute
-/// with any type's `FromType<YourHasSchemaType>` implementation like so:
+/// This attribute is simply a shortcut equivalent to using the type_data
+/// attribute with any type's `FromType<YourHasSchemaType>` implementation like
+/// so:
 /// ```ignore
 /// #[derive(HasSchema, Clone, Default)]
 /// #[type_data(<OtherType as FromType<Data>>::from_type())]
@@ -77,8 +95,8 @@ macro_rules! throw {
 /// ```
 /// ## Known Limitations
 ///
-/// Currently it isn't possible to construct a struct that contains itself. For example, this will
-/// not work:
+/// Currently it isn't possible to construct a struct that contains itself. For
+/// example, this will not work:
 ///
 /// ```ignore
 /// #[derive(HasSchema)]
@@ -155,6 +173,8 @@ pub fn derive_has_schema(input: TokenStream) -> TokenStream {
     let schema_flags = get_flags_for_attr(&input, "schema");
     let no_clone = schema_flags.iter().any(|x| x.as_str() == "no_clone");
     let no_default = schema_flags.iter().any(|x| x.as_str() == "no_default");
+    let has_hash = schema_flags.iter().any(|x| x.as_str() == "hash");
+    let has_eq = schema_flags.iter().any(|x| x.as_str() == "eq");
     let is_opaque = schema_flags.iter().any(|x| x.as_str() == "opaque")
         || !(repr_c || primitive_repr.is_some());
 
@@ -169,6 +189,16 @@ pub fn derive_has_schema(input: TokenStream) -> TokenStream {
     } else {
         quote!(Some(<Self as #schema_mod::raw_fns::RawDefault>::raw_default_cb()))
     };
+    let hash_fn = if !has_hash {
+        quote!(None)
+    } else {
+        quote!(Some(<Self as #schema_mod::raw_fns::RawHash>::raw_hash_cb()))
+    };
+    let eq_fn = if !has_eq {
+        quote!(None)
+    } else {
+        quote!(Some(<Self as #schema_mod::raw_fns::RawEq>::raw_eq_cb()))
+    };
 
     // Get the schema kind
     let schema_kind = (|| {
@@ -228,8 +258,8 @@ pub fn derive_has_schema(input: TokenStream) -> TokenStream {
                                             type_data: #type_datas,
                                             clone_fn: #clone_fn,
                                             default_fn: #default_fn,
-                                            eq_fn: None,
-                                            hash_fn: None,
+                                            eq_fn: #eq_fn,
+                                            hash_fn: #hash_fn,
                                             drop_fn: Some(<Self as #schema_mod::raw_fns::RawDrop>::raw_drop_cb()),
                                         })
                                     },
@@ -358,8 +388,8 @@ pub fn derive_has_schema(input: TokenStream) -> TokenStream {
             type_data: #type_datas,
             default_fn: #default_fn,
             clone_fn: #clone_fn,
-            eq_fn: None,
-            hash_fn: None,
+            eq_fn: #eq_fn,
+            hash_fn: #hash_fn,
             drop_fn: Some(<Self as #schema_mod::raw_fns::RawDrop>::raw_drop_cb()),
         })
     };

From d8b8554726be8e201e447dee93f94b09fd2268dd Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Fri, 31 Jul 2026 09:12:22 -0500
Subject: [PATCH 20/36] feat: impl From<T> for Maybe<T>

---
 framework_crates/bones_asset/src/lib.rs | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/framework_crates/bones_asset/src/lib.rs b/framework_crates/bones_asset/src/lib.rs
index 3c8c94e7b2..b54576826a 100644
--- a/framework_crates/bones_asset/src/lib.rs
+++ b/framework_crates/bones_asset/src/lib.rs
@@ -282,6 +282,13 @@ impl<T> From<Option<T>> for Maybe<T> {
     }
 }
 
+impl<T> From<T> for Maybe<T> {
+    #[inline]
+    fn from(value: T) -> Self {
+        Maybe::Set(value)
+    }
+}
+
 fn maybe_loader(
     ctx: &mut MetaAssetLoadCtx,
     ptr: SchemaRefMut<'_>,

From 7f736d1a1e69993c50b854208b07695a32dc0823 Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Fri, 31 Jul 2026 09:14:01 -0500
Subject: [PATCH 21/36] chore: add todo, remove todo

---
 framework_crates/bones_framework/src/render/camera.rs | 1 -
 framework_crates/bones_schema/src/raw_fns.rs          | 1 +
 2 files changed, 1 insertion(+), 1 deletion(-)

diff --git a/framework_crates/bones_framework/src/render/camera.rs b/framework_crates/bones_framework/src/render/camera.rs
index a12d9e1625..75cd007622 100644
--- a/framework_crates/bones_framework/src/render/camera.rs
+++ b/framework_crates/bones_framework/src/render/camera.rs
@@ -16,7 +16,6 @@ pub struct Camera {
     /// The height of the camera in in-game pixels.
     ///
     /// The width of the camera will be determined from the window aspect ratio.
-    // TODO: implement different scaling modes for bones cameras.
     pub size: CameraSize,
     /// Whether or not the camera is enabled and rendering.
     pub active: bool,
diff --git a/framework_crates/bones_schema/src/raw_fns.rs b/framework_crates/bones_schema/src/raw_fns.rs
index 9eb3bd9bdf..07b3ee1535 100644
--- a/framework_crates/bones_schema/src/raw_fns.rs
+++ b/framework_crates/bones_schema/src/raw_fns.rs
@@ -91,6 +91,7 @@ impl<T: Hash> RawHash for T {
 /// Trait implemented automatically for types that implement [`Eq`] that can compare two values
 /// through their pointers.
 pub trait RawEq {
+    // TODO: correctly document this function ( it thinks it is `raw_hash` )
     /// Get the hash of the type.
     ///
     /// # Safety

From eed5887960c0bfae97cfdf26c3bd67c6b612483b Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Fri, 31 Jul 2026 09:14:40 -0500
Subject: [PATCH 22/36] feat: impl HasSchema for MouseButton

---
 framework_crates/bones_framework/src/input/mouse.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/framework_crates/bones_framework/src/input/mouse.rs b/framework_crates/bones_framework/src/input/mouse.rs
index 76c99e9c6b..b2837cf7a8 100644
--- a/framework_crates/bones_framework/src/input/mouse.rs
+++ b/framework_crates/bones_framework/src/input/mouse.rs
@@ -42,7 +42,7 @@ pub struct MouseButtonEvent {
 }
 
 /// A button on the mouse.
-#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(HasSchema, Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
 #[repr(u8)]
 pub enum MouseButton {
     #[default]

From 5e5a7ca050dfc1e3872933db66d063125b6e9e7b Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Fri, 31 Jul 2026 09:17:06 -0500
Subject: [PATCH 23/36] feat: allow any schema for key deserialization

---
 framework_crates/bones_schema/src/ser_de.rs | 27 +++++++++------------
 1 file changed, 12 insertions(+), 15 deletions(-)

diff --git a/framework_crates/bones_schema/src/ser_de.rs b/framework_crates/bones_schema/src/ser_de.rs
index 57a44acee5..ffb2fe6767 100644
--- a/framework_crates/bones_schema/src/ser_de.rs
+++ b/framework_crates/bones_schema/src/ser_de.rs
@@ -14,7 +14,7 @@ mod serializer_deserializer {
         de::{Unexpected, VariantAccess, Visitor},
         ser::{SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant},
     };
-    use ustr::{ustr, Ustr};
+    use ustr::Ustr;
 
     use super::*;
 
@@ -301,8 +301,8 @@ mod serializer_deserializer {
         {
             // SOUND: schema asserts this is a SchemaVec.
             let v = unsafe { &mut *(self.0.as_ptr() as *mut SchemaVec) };
+            let item_schema = v.schema();
             loop {
-                let item_schema = v.schema();
                 let mut item = SchemaBox::default(item_schema);
                 let item_ref = item.as_mut();
                 if seq.next_element_seed(item_ref)?.is_none() {
@@ -331,19 +331,16 @@ mod serializer_deserializer {
         {
             // SOUND: schema asserts this is a SchemaMap.
             let v = unsafe { &mut *(self.0.as_ptr() as *mut SchemaMap) };
-            let is_ustr = v.key_schema() == Ustr::schema();
-            if v.key_schema() != String::schema() && !is_ustr {
-                return Err(A::Error::custom(
-                    "Can only deserialize maps with `String` or `Ustr` keys.",
-                ));
-            }
-            while let Some(key) = map.next_key::<String>()? {
-                let key = if is_ustr {
-                    SchemaBox::new(ustr(&key))
-                } else {
-                    SchemaBox::new(key)
-                };
-                let mut value = SchemaBox::default(v.value_schema());
+
+            let key_schema = v.key_schema();
+            let value_schema = v.value_schema();
+            loop {
+                let mut key = SchemaBox::default(key_schema);
+                let mut value = SchemaBox::default(value_schema);
+
+                if map.next_key_seed(key.as_mut())?.is_none() {
+                    break;
+                }
                 map.next_value_seed(value.as_mut())?;
 
                 v.insert_box(key, value);

From c87e8500a6499fe764eea9757af198a03c7bcddc Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Fri, 31 Jul 2026 11:16:07 -0500
Subject: [PATCH 24/36] refactor!: adds the gilrs GamepadId to the bones
 gamepad events and publicizes the GILRS_CONTEXT. This removes the default
 implementation from the gamepad events and thus adds the no_default attribute
 to their schema.

This changes how the events can be used in scripts but it is largely expected that you won't handle that level of inputs in scripts.
---
 .../bones_framework/src/input/gamepad.rs      | 25 ++++++++++---------
 .../bones_framework/src/input/gilrs.rs        |  7 +++---
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/framework_crates/bones_framework/src/input/gamepad.rs b/framework_crates/bones_framework/src/input/gamepad.rs
index 37639ec5d4..f8ea2f8f90 100644
--- a/framework_crates/bones_framework/src/input/gamepad.rs
+++ b/framework_crates/bones_framework/src/input/gamepad.rs
@@ -12,6 +12,7 @@ pub struct GamepadInputs {
 
 /// A gamepad event.
 #[derive(HasSchema, Clone, Copy, Debug)]
+#[schema(no_default)]
 #[repr(C, u8)]
 pub enum GamepadEvent {
     /// A connection event.
@@ -22,18 +23,14 @@ pub enum GamepadEvent {
     Axis(GamepadAxisEvent),
 }
 
-impl Default for GamepadEvent {
-    fn default() -> Self {
-        Self::Connection(default())
-    }
-}
-
 /// A gamepad connection event.
-#[derive(HasSchema, Clone, Copy, Debug, Default)]
+#[derive(HasSchema, Clone, Copy, Debug)]
+#[schema(no_default)]
 #[repr(C)]
 pub struct GamepadConnectionEvent {
     /// The ID of the gamepad.
-    pub gamepad: u32,
+    #[schema(opaque)]
+    pub gamepad: gilrs::GamepadId,
     /// The type of connection event.
     pub event: GamepadConnectionEventKind,
 }
@@ -50,11 +47,13 @@ pub enum GamepadConnectionEventKind {
 }
 
 /// A gamepad button event.
-#[derive(HasSchema, Clone, Copy, Debug, Default)]
+#[derive(HasSchema, Clone, Copy, Debug)]
+#[schema(no_default)]
 #[repr(C)]
 pub struct GamepadButtonEvent {
     /// The ID of the gamepad.
-    pub gamepad: u32,
+    #[schema(opaque)]
+    pub gamepad: gilrs::GamepadId,
     /// The gamepad button.
     pub button: GamepadButton,
     /// The value of the button, for example, this will be `1.0` when presssed and `0.0` when
@@ -76,6 +75,7 @@ pub struct GamepadButtonEvent {
     serde::Deserialize,
     serde::Serialize,
 )]
+#[schema(hash, eq)]
 #[repr(C, u8)]
 pub enum GamepadButton {
     #[default]
@@ -138,7 +138,8 @@ impl std::fmt::Display for GamepadButton {
 #[repr(C)]
 pub struct GamepadAxisEvent {
     /// The ID of the gamepad.
-    pub gamepad: u32,
+    #[schema(opaque)]
+    pub gamepad: gilrs::GamepadId,
     /// The axis that has changed.
     pub axis: GamepadAxis,
     /// The value of the axis.
@@ -149,7 +150,7 @@ pub struct GamepadAxisEvent {
 #[derive(
     HasSchema, Clone, Copy, Debug, PartialEq, Eq, Hash, serde::Deserialize, serde::Serialize,
 )]
-#[schema(no_default)]
+#[schema(no_default, hash, eq)]
 #[allow(missing_docs)]
 #[repr(C, u8)]
 pub enum GamepadAxis {
diff --git a/framework_crates/bones_framework/src/input/gilrs.rs b/framework_crates/bones_framework/src/input/gilrs.rs
index 5e8df1f4ad..a93a370e49 100644
--- a/framework_crates/bones_framework/src/input/gilrs.rs
+++ b/framework_crates/bones_framework/src/input/gilrs.rs
@@ -9,7 +9,7 @@ use send_wrapper::SendWrapper;
 
 /// Lazy-initialized GilrsContext
 #[cfg(not(target_arch = "wasm32"))]
-static GILRS_CONTEXT: Lazy<Arc<Mutex<GilrsContext>>> = Lazy::new(|| {
+pub static GILRS_CONTEXT: Lazy<Arc<Mutex<GilrsContext>>> = Lazy::new(|| {
     Arc::new(Mutex::new(
         GilrsContext::new().expect("Failed to initialize GilrsContext"),
     ))
@@ -20,7 +20,7 @@ static GILRS_CONTEXT: Lazy<Arc<Mutex<GilrsContext>>> = Lazy::new(|| {
 // accessed from one thread.
 /// Lazy-initialized GilrsContext
 #[cfg(target_arch = "wasm32")]
-static GILRS_CONTEXT: Lazy<Arc<Mutex<SendWrapper<GilrsContext>>>> = Lazy::new(|| {
+pub static GILRS_CONTEXT: Lazy<Arc<Mutex<SendWrapper<GilrsContext>>>> = Lazy::new(|| {
     Arc::new(Mutex::new(SendWrapper::new(
         GilrsContext::new().expect("Failed to initialize GilrsContext"),
     )))
@@ -36,10 +36,9 @@ pub fn process_gamepad_events() -> GamepadInputs {
     {
         gilrs.update(&gilrs_event);
 
-        let gamepad = usize::from(gilrs_event.id) as u32;
+        let gamepad = gilrs_event.id;
         match gilrs_event.event {
             EventType::Connected => {
-                let _pad = gilrs.gamepad(gilrs_event.id);
                 gamepad_inputs.gamepad_events.push(GamepadEvent::Connection(
                     GamepadConnectionEvent {
                         gamepad,

From 25d3a839b4690e7b6ec38150725482c8634f98a9 Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Sat, 1 Aug 2026 22:41:35 -0500
Subject: [PATCH 25/36] refactor!: require default for network Controls

---
 framework_crates/bones_framework/src/input.rs      | 2 +-
 framework_crates/bones_framework/src/networking.rs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/framework_crates/bones_framework/src/input.rs b/framework_crates/bones_framework/src/input.rs
index d87a74837f..6e3a7f3fcf 100644
--- a/framework_crates/bones_framework/src/input.rs
+++ b/framework_crates/bones_framework/src/input.rs
@@ -98,7 +98,7 @@ pub trait DenseInputConfig<'a> {
     type Control: DenseControl<Self::Dense>;
 
     // Must be HasSchema because expected to be retrieved from `World` as `Resource`.
-    type Controls: Controls<'a, Self::Control> + HasSchema;
+    type Controls: Controls<'a, Self::Control> + HasSchema + Default;
 
     // InputCollector type params must match that of Controls, so using associated types.
     type InputCollector: InputCollector<'a, Self::Control> + Default;
diff --git a/framework_crates/bones_framework/src/networking.rs b/framework_crates/bones_framework/src/networking.rs
index ab6bac4097..40b39760d0 100644
--- a/framework_crates/bones_framework/src/networking.rs
+++ b/framework_crates/bones_framework/src/networking.rs
@@ -843,7 +843,7 @@ where
 
                                         // update game controls from ggrs inputs
                                         let mut player_inputs =
-                                            world.resource_mut::<InputTypes::Controls>();
+                                            world.init_resource::<InputTypes::Controls>();
                                         for (player_idx, (input, status)) in
                                             network_inputs.into_iter().enumerate()
                                         {

From ed63b64df084317f9873dde4b8737956b81201bf Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Sun, 2 Aug 2026 09:08:09 -0500
Subject: [PATCH 26/36] doc: explain ResetWorld standard kept resources

---
 framework_crates/bones_lib/src/reset.rs | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/framework_crates/bones_lib/src/reset.rs b/framework_crates/bones_lib/src/reset.rs
index 9e20fe3f30..a2b1577c7e 100644
--- a/framework_crates/bones_lib/src/reset.rs
+++ b/framework_crates/bones_lib/src/reset.rs
@@ -37,7 +37,13 @@ impl ResetWorld {
     /// Create a [`ResetWorld`] that already keeps some basic special resources
     /// that are usually needed like [`SessionOptions`] & [`Entities`].
     pub fn standard() -> Self {
-        Self::empty().keep::<Entities>().keep::<SessionOptions>()
+        Self::empty()
+            // Even though Entities is completely cleared on reset, it is always
+            // expected everywhere so we can't remove it from the World.
+            .keep::<Entities>()
+            // SessionOptions is re-inserted every frame, but may still be
+            // wanted right after reset and is expected in `Game` right now.
+            .keep::<SessionOptions>()
     }
     /// Adds the [`SchemaId`] of the type given to the set of resources to keep
     /// on reset.

From eb7ba94d2407bac2b23d5d430b6d044ec732259c Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Thu, 6 Aug 2026 10:19:55 -0500
Subject: [PATCH 27/36] refactor!: revert gilrs::GamepadId implementation into
 bones gamepad events in favor of simpler method of obtaining gilrs::Gamepad
 data.

Instead of giving the gilrs::GamepadId directly and therefore disallowing arbitrary ids which can be useful for testing and more, the gilrs::Gamepad data can technically still be obtained optionally with an arbitrary id with Gilrs::gamepads.
---
 .../bones_framework/src/input/gamepad.rs      | 22 +++++++++----------
 .../bones_framework/src/input/gilrs.rs        |  2 +-
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/framework_crates/bones_framework/src/input/gamepad.rs b/framework_crates/bones_framework/src/input/gamepad.rs
index f8ea2f8f90..1cd07ac1a0 100644
--- a/framework_crates/bones_framework/src/input/gamepad.rs
+++ b/framework_crates/bones_framework/src/input/gamepad.rs
@@ -12,7 +12,6 @@ pub struct GamepadInputs {
 
 /// A gamepad event.
 #[derive(HasSchema, Clone, Copy, Debug)]
-#[schema(no_default)]
 #[repr(C, u8)]
 pub enum GamepadEvent {
     /// A connection event.
@@ -23,14 +22,18 @@ pub enum GamepadEvent {
     Axis(GamepadAxisEvent),
 }
 
+impl Default for GamepadEvent {
+    fn default() -> Self {
+        Self::Connection(default())
+    }
+}
+
 /// A gamepad connection event.
-#[derive(HasSchema, Clone, Copy, Debug)]
-#[schema(no_default)]
+#[derive(HasSchema, Clone, Copy, Debug, Default)]
 #[repr(C)]
 pub struct GamepadConnectionEvent {
     /// The ID of the gamepad.
-    #[schema(opaque)]
-    pub gamepad: gilrs::GamepadId,
+    pub gamepad: u32,
     /// The type of connection event.
     pub event: GamepadConnectionEventKind,
 }
@@ -47,13 +50,11 @@ pub enum GamepadConnectionEventKind {
 }
 
 /// A gamepad button event.
-#[derive(HasSchema, Clone, Copy, Debug)]
-#[schema(no_default)]
+#[derive(HasSchema, Clone, Copy, Debug, Default)]
 #[repr(C)]
 pub struct GamepadButtonEvent {
     /// The ID of the gamepad.
-    #[schema(opaque)]
-    pub gamepad: gilrs::GamepadId,
+    pub gamepad: u32,
     /// The gamepad button.
     pub button: GamepadButton,
     /// The value of the button, for example, this will be `1.0` when presssed and `0.0` when
@@ -138,8 +139,7 @@ impl std::fmt::Display for GamepadButton {
 #[repr(C)]
 pub struct GamepadAxisEvent {
     /// The ID of the gamepad.
-    #[schema(opaque)]
-    pub gamepad: gilrs::GamepadId,
+    pub gamepad: u32,
     /// The axis that has changed.
     pub axis: GamepadAxis,
     /// The value of the axis.
diff --git a/framework_crates/bones_framework/src/input/gilrs.rs b/framework_crates/bones_framework/src/input/gilrs.rs
index a93a370e49..12d66afadb 100644
--- a/framework_crates/bones_framework/src/input/gilrs.rs
+++ b/framework_crates/bones_framework/src/input/gilrs.rs
@@ -36,7 +36,7 @@ pub fn process_gamepad_events() -> GamepadInputs {
     {
         gilrs.update(&gilrs_event);
 
-        let gamepad = gilrs_event.id;
+        let gamepad = usize::from(gilrs_event.id) as u32;
         match gilrs_event.event {
             EventType::Connected => {
                 gamepad_inputs.gamepad_events.push(GamepadEvent::Connection(

From 188fe8392ffdc1194c717e43a8edf5da5987ee08 Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Fri, 14 Aug 2026 18:39:14 -0500
Subject: [PATCH 28/36] doc: add doc & todo

---
 framework_crates/bones_ecs/src/stage.rs | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/framework_crates/bones_ecs/src/stage.rs b/framework_crates/bones_ecs/src/stage.rs
index 7774dbe086..17d11daa33 100644
--- a/framework_crates/bones_ecs/src/stage.rs
+++ b/framework_crates/bones_ecs/src/stage.rs
@@ -147,7 +147,9 @@ impl SystemStages {
     /// struct ResourceBeingInserted;
     /// ```
     /// Then the system being added to the [`Startup`] system stage will panic
-    /// when inserting a second time.
+    /// when inserting a second time. The startup stage only runs once so it is
+    /// therefore safe to use a type like the example above as long as you don't
+    /// plan on removing the [`StartupSystemsRan`] resource from the [`World`].
     pub fn add_startup_resource<R: HasSchema>(&mut self, resource: R) -> &mut Self {
         let mut once = Some(SchemaBox::new(resource));
 
@@ -348,6 +350,12 @@ where
     .system()
 }
 
+// TODO: Figure out a name for a function that creates a single success system
+// with the Ulid created automatically internally. Maybe rename the current
+// function to something else and have the auto-generated id function as
+// standard since there is probably only a slim possibility that you will need
+// to re-use a Ulid for these kind of systems.
+
 /// Resource tracking which of single success systems have completed with a
 /// [`HashSet`] of [`Ulid`] for the succeeded.
 #[derive(HasSchema, Clone, Default, Deref, DerefMut)]

From a43616a6e15030a3d3ffa64087891dd19316f1fb Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Fri, 14 Aug 2026 18:39:54 -0500
Subject: [PATCH 29/36] feat: add builder functions to `Session`

---
 framework_crates/bones_lib/src/lib.rs | 44 ++++++++++++++++++++++++++-
 1 file changed, 43 insertions(+), 1 deletion(-)

diff --git a/framework_crates/bones_lib/src/lib.rs b/framework_crates/bones_lib/src/lib.rs
index 0218440aaa..0b779f1175 100644
--- a/framework_crates/bones_lib/src/lib.rs
+++ b/framework_crates/bones_lib/src/lib.rs
@@ -28,6 +28,7 @@ use crate::prelude::*;
 
 /// Contains a bones [`World`] for state, [`SystemStages`] for behavior, and a
 /// [`SessionRunner`] to determine how those are used.
+// TODO: add network safety docs for `Session`.
 #[non_exhaustive]
 #[derive(Deref, DerefMut)]
 pub struct Session {
@@ -60,7 +61,47 @@ impl Default for Session {
 }
 
 impl Session {
-    /// Install a plugin.
+    /// Set the priority of this session relative to other sessions in the [`Game`].
+    pub fn priority(&mut self, priority: i32) -> &mut Self {
+        self.priority = priority;
+        self
+    }
+    /// Set the [`SessionRunner`] to use for this session.
+    pub fn runner(&mut self, runner: Box<dyn SessionRunner>) -> &mut Self {
+        self.runner = runner;
+        self
+    }
+    /// Set whether or not this session should have it's systems run.
+    pub fn activity(&mut self, active: bool) -> &mut Self {
+        self.active = active;
+        self
+    }
+    /// Set whether or not this session should be rendered.
+    pub fn visibility(&mut self, visible: bool) -> &mut Self {
+        self.visible = visible;
+        self
+    }
+    /// Set this session to be rendered.
+    pub fn visible(&mut self) -> &mut Self {
+        self.visible = true;
+        self
+    }
+    /// Set this session to not be rendered.
+    pub fn invisible(&mut self) -> &mut Self {
+        self.visible = false;
+        self
+    }
+    /// Set this session to have it's systems run.
+    pub fn active(&mut self) -> &mut Self {
+        self.active = true;
+        self
+    }
+    /// Set this session to not have it's systems run.
+    pub fn inactive(&mut self) -> &mut Self {
+        self.active = false;
+        self
+    }
+    /// Install a [`SessionPlugin`].
     pub fn install_plugin(&mut self, plugin: impl SessionPlugin) -> &mut Self {
         plugin.install(self);
         self
@@ -592,6 +633,7 @@ impl Sessions {
         self.map.get_mut(&name).unwrap()
     }
 
+    // TODO: `create_with` should be removed if `create` stays appropriate.
     /// Create a new session, and borrow it mutably so it can be modified.
     #[track_caller]
     pub fn create_with<K: TryInto<Ustr>>(

From f738b808a7a15461cfb0f43bda1dc4815b08577e Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Fri, 14 Aug 2026 18:40:49 -0500
Subject: [PATCH 30/36] fix: test compile error

---
 framework_crates/bones_framework/tests/reset.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/framework_crates/bones_framework/tests/reset.rs b/framework_crates/bones_framework/tests/reset.rs
index 88e6affb59..4b8087f8d1 100644
--- a/framework_crates/bones_framework/tests/reset.rs
+++ b/framework_crates/bones_framework/tests/reset.rs
@@ -44,7 +44,7 @@ pub fn single_success_system_reset() {
     let mut game = Game::new();
 
     game.sessions
-        .create_with("game")
+        .create("game")
         // Counter should not be kept on reset.
         .add_system_to_stage(Startup, |world: &World| {
             world.insert_resource(Counter(0));

From 302370f9cc11f7a508a31961fe10bbbf21abd0d8 Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Fri, 14 Aug 2026 18:41:32 -0500
Subject: [PATCH 31/36] refactor!: revamp and cleanup network input collection
 and docs.

---
 framework_crates/bones_framework/src/input.rs | 135 +++++++-----------
 .../bones_framework/src/networking.rs         |  10 +-
 .../bones_framework/src/networking/input.rs   |   7 -
 3 files changed, 59 insertions(+), 93 deletions(-)

diff --git a/framework_crates/bones_framework/src/input.rs b/framework_crates/bones_framework/src/input.rs
index 6e3a7f3fcf..6fc7ebbce9 100644
--- a/framework_crates/bones_framework/src/input.rs
+++ b/framework_crates/bones_framework/src/input.rs
@@ -2,6 +2,7 @@
 
 use bones_lib::ecs::World;
 use bones_schema::HasSchema;
+use std::fmt::Debug;
 
 pub mod gamepad;
 pub mod gilrs;
@@ -10,7 +11,7 @@ pub mod mouse;
 pub mod proto;
 pub mod window;
 
-/// The state of a button, ether pressed or released.
+/// The state of a button, either pressed or released.
 #[derive(HasSchema, Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
 #[repr(u8)]
 pub enum ButtonState {
@@ -31,41 +32,45 @@ impl ButtonState {
 /// Module prelude.
 pub mod prelude {
     pub use super::{gamepad::*, keyboard::*, mouse::*, proto, window::*, ButtonState};
-    pub use crate::input::{
-        Controls, DenseControl, DenseInput, DenseInputCollector, DenseInputConfig, InputCollector,
-    };
+    pub use crate::input::{Controls, DenseControl, DenseInput, DenseInputConfig, InputCollector};
 }
 
-/// Maps raw inputs to game controls and exposes controls for respective player and their control source.
-///
-/// [`InputCollector::apply_inputs`] maps raw input to game controls and updates them.
-///
-/// [`InputCollector::update_just_pressed`] computes any changes in pressed buttons that may be stored on control.
-///
-/// [`InputCollector::advance_frame`] is  used to mark that the input has been consumed, and update the prev frame inputs to current, to compute changes next frame.
-pub trait InputCollector<'a, Control>: Send + Sync {
-    /// Update the internal state with new inputs. This must be called every render frame with the
-    /// input events. This updates which buttons are pressed, but does not compute what buttons were "just_pressed".
-    /// use [`InputCollector::update_just_pressed`] to do this.
+/// Dense input super trait for network replication.
+pub trait DenseInput:
+    bytemuck::Pod + bytemuck::Zeroable + Copy + Clone + PartialEq + Eq + Send + Sync
+{
+}
+// Automatic implementation for `DenseInput`.
+impl<T> DenseInput for T where
+    T: bytemuck::Pod + bytemuck::Zeroable + Copy + Clone + PartialEq + Eq + Send + Sync
+{
+}
+
+/// Collects local input state for the network client from the [`World`].
+pub trait InputCollector<'a, State>: Send + Sync {
+    /// Update the internal state with the [`World`].
+    ///
+    /// This should be called every render frame / cpu cycle after input events.
     fn apply_inputs(&mut self, world: &World);
 
-    /// Indicate input for this frame has been consumed. An implementation of [`InputCollector`] that is
-    /// used with a fixed simulation step may track what keys are currently pressed, and what keys were "just pressed",
-    /// (changing from previous state).
+    /// Indicates to the collector that its input has been consumed.
     ///
-    /// This saves current inputs as previous frame's inputs, allowing for determining what is "just pressed" next frame.
+    /// This should be called on frame update when input for this frame has been
+    /// consumed as opposed to the cpu cycle. In a network session, by the time
+    /// this is called, the dense input should be sent across the network.
     fn advance_frame(&mut self);
 
-    /// Update which buttons have been "just pressed", when input has changed from last frame and current input state.
-    ///
-    /// This does not modify previous frame's input, to do this use [`InputCollector::advance_frame`].
-    fn update_just_pressed(&mut self);
+    /// Get the internally stored input state.
+    fn get_state(&self) -> State;
+}
 
-    /// Get control for player.
-    fn get_control(&self) -> &Control;
+/// A trait representing a control type capable of being updated by a [`DenseInput`].
+pub trait DenseControl<Dense: DenseInput>: Send + Sync + Default {
+    /// Update this control with a [`DenseInput`].
+    fn update_from_dense(&mut self, new_control: &Dense);
 }
 
-/// Trait that tracks player control state. Provides associated types for other input trait implementations.
+/// Trait for getting every player control via index.
 pub trait Controls<'a, Control> {
     /// Get control for player.
     fn get_control(&self, player_idx: usize) -> &Control;
@@ -74,67 +79,31 @@ pub trait Controls<'a, Control> {
     fn get_control_mut(&mut self, player_idx: usize) -> &mut Control;
 }
 
-use std::fmt::Debug;
-
-/// Dense input for network replication.
-pub trait DenseInput:
-    bytemuck::Pod + bytemuck::Zeroable + Copy + Clone + PartialEq + Eq + Send + Sync
-{
-}
-
-/// Automatic implementation for `DenseInput`.
-impl<T> DenseInput for T where
-    T: bytemuck::Pod + bytemuck::Zeroable + Copy + Clone + PartialEq + Eq + Send + Sync
-{
-}
-
-/// Define input types used by game for use in networking.
-///
-/// As long as types `Controls` and `InputCollector` implement traits [`Controls`] and [`InputCollector`],
-/// trait bounds [`DenseControl`] and [`DenseInputCollector`] are automatically implemented.
+/// Defines input types for use in networking.
 #[allow(missing_docs)]
 pub trait DenseInputConfig<'a> {
+    /// Current input state for a client. This is what is sent across the
+    /// network. All input history and other data derived from the state should
+    /// be stored by the [`Control`](DenseInputConfig::Control).
     type Dense: DenseInput + Debug + Default;
-    type Control: DenseControl<Self::Dense>;
-
-    // Must be HasSchema because expected to be retrieved from `World` as `Resource`.
-    type Controls: Controls<'a, Self::Control> + HasSchema + Default;
-
-    // InputCollector type params must match that of Controls, so using associated types.
-    type InputCollector: InputCollector<'a, Self::Control> + Default;
-}
-
-///  Trait allowing for creating and applying [`DenseInput`] from control.
-pub trait DenseControl<Dense: DenseInput>: Send + Sync + Default {
-    /// Get [`DenseInput`] for control.
-    fn get_dense_input(&self) -> Dense;
 
-    /// Update control from [`DenseInput`].
-    fn update_from_dense(&mut self, new_control: &Dense);
-}
+    /// Local configuration for getting [`Dense`](DenseInputConfig::Dense) from
+    /// the [`World`] to be sent across the network.
+    type InputCollector: InputCollector<'a, Self::Dense> + Default;
 
-/// Extension of [`InputCollector`] exposing dense control for networking.
-///
-/// This trait is automatically implemented for [`InputCollector`]'s such that `Control`
-/// implements [`DenseControl`] (i.e. implements dense input)
-pub trait DenseInputCollector<'a, Dense, Control>: InputCollector<'a, Control>
-where
-    Dense: DenseInput,
-    Control: DenseControl<Dense>,
-{
-    /// Get dense control
-    fn get_dense_control(&self) -> Dense;
-}
+    /// The complete input data of a client. Updated with
+    /// [`Dense`](DenseInputConfig::Dense) when recieved from the network. The
+    /// [`Controls`](DenseInputConfig::Controls) resource in the [`World`] will
+    /// contain every client's control after update.
+    type Control: DenseControl<Self::Dense>;
 
-/// Provide automatic [`DenseInputCollector`] for [`InputCollector`] when type parameters
-/// meet required bounds for networking.
-impl<'a, T, Dense, Control> DenseInputCollector<'a, Dense, Control> for T
-where
-    Dense: DenseInput,
-    Control: DenseControl<Dense>,
-    T: InputCollector<'a, Control>,
-{
-    fn get_dense_control(&self) -> Dense {
-        self.get_control().get_dense_input()
-    }
+    /// The resource that will contain a [`Control`](DenseInputConfig::Control)
+    /// for every client in a network session.
+    type Controls: Controls<'a, Self::Control>
+        // HasSchema because expected to be retrieved from `World` as
+        // `Resource`.
+        + HasSchema
+        // Default because not expected to be initialized when retrieved from
+        // `World`.
+        + Default;
 }
diff --git a/framework_crates/bones_framework/src/networking.rs b/framework_crates/bones_framework/src/networking.rs
index 40b39760d0..e00c721c37 100644
--- a/framework_crates/bones_framework/src/networking.rs
+++ b/framework_crates/bones_framework/src/networking.rs
@@ -1,7 +1,7 @@
 #![doc = include_str!("./networking.md")]
 
 use self::{input::NetworkControls, socket::Socket};
-use crate::input::{DenseControl, DenseInput, DenseInputConfig};
+use crate::input::{DenseInput, DenseInputConfig};
 use crate::networking::online::OnlineMatchmakerResponse;
 pub use crate::networking::random::RngGenerator;
 use crate::prelude::*;
@@ -655,10 +655,9 @@ where
 
         // Collect inputs and update controls
         self.input_collector.apply_inputs(world);
-        self.input_collector.update_just_pressed();
 
         // save local players dense input for use with ggrs
-        self.last_player_input = self.input_collector.get_control().get_dense_input();
+        self.last_player_input = self.input_collector.get_state();
 
         #[cfg(feature = "net-debug")]
         // Current frame before we start network update loop
@@ -788,6 +787,11 @@ where
                                     inputs: network_inputs,
                                 } => {
                                     // Input has been consumed, signal that we are in new input frame
+
+                                    // TODO: only call `InputCollector::advance_frame`
+                                    // when we are in a "prediction frame", not a "rollback catchup frame".
+                                    // If there are requests to load a snapshot and re-run frames the
+                                    // input collector's input has already been defined for those frames.
                                     self.input_collector.advance_frame();
 
                                     // Fetch the PlayerNetworkStats for each remote player, guaranteeing each one is inserted into the index matching its handle
diff --git a/framework_crates/bones_framework/src/networking/input.rs b/framework_crates/bones_framework/src/networking/input.rs
index 52ff4eb826..ca87c268d1 100644
--- a/framework_crates/bones_framework/src/networking/input.rs
+++ b/framework_crates/bones_framework/src/networking/input.rs
@@ -16,9 +16,6 @@ pub trait NetworkControls<'a, Dense: DenseInput, Control>: Controls<'a, Control>
         dense_input: &Dense,
         status: NetworkInputStatus,
     );
-
-    /// Get dense control for player.
-    fn get_dense_control(&self, player_idx: usize) -> Dense;
 }
 
 impl<'a, T, Dense, Control> NetworkControls<'a, Dense, Control> for T
@@ -37,8 +34,4 @@ where
         self.get_control_mut(player_idx)
             .update_from_dense(dense_input);
     }
-
-    fn get_dense_control(&self, player_idx: usize) -> Dense {
-        self.get_control(player_idx).get_dense_input()
-    }
 }

From 38016c41f9bd0c48a2ed56ab10da7bcfa4c36220 Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Sat, 12 Sep 2026 14:21:04 -0500
Subject: [PATCH 32/36] fix!: remove `tile_size` field from EntityGridMap since
 this value isn't related to this type itself.

---
 demos/features/src/main.rs                       |  3 +--
 .../bones_bevy_renderer/src/render.rs            |  2 +-
 .../bones_framework/src/render/tilemap.rs        | 16 ++++------------
 3 files changed, 6 insertions(+), 15 deletions(-)

diff --git a/demos/features/src/main.rs b/demos/features/src/main.rs
index 3edcb371ef..b7ac675f39 100644
--- a/demos/features/src/main.rs
+++ b/demos/features/src/main.rs
@@ -365,10 +365,9 @@ fn tilemap_startup_system(
 
     // Load our map and atlas info
     let map_info = assets.get(meta.tilemap_demo);
-    let atlas = assets.get(map_info.atlas);
 
     // Create a new map layer
-    let mut layer = TileLayer::new(map_info.map_size, atlas.tile_size, map_info.atlas);
+    let mut layer = TileLayer::new(map_info.map_size, map_info.atlas);
 
     // Load the layer up with the tiles from our metadata
     for tile in &map_info.tiles {
diff --git a/framework_crates/bones_bevy_renderer/src/render.rs b/framework_crates/bones_bevy_renderer/src/render.rs
index 41eb2a70c5..8e20bb82b6 100644
--- a/framework_crates/bones_bevy_renderer/src/render.rs
+++ b/framework_crates/bones_bevy_renderer/src/render.rs
@@ -430,7 +430,7 @@ pub fn extract_bones_tilemaps(
                 let tile = tiles.get(*tile_ent).unwrap();
 
                 let tile_pos = tile_layer.pos(tile_pos_idx as u32);
-                let tile_offset = tile_pos.as_vec2() * tile_layer.tile_size;
+                let tile_offset = tile_pos.as_vec2() * atlas.tile_size;
 
                 let sprite_idx = tile.idx;
                 let y = sprite_idx / atlas.columns;
diff --git a/framework_crates/bones_framework/src/render/tilemap.rs b/framework_crates/bones_framework/src/render/tilemap.rs
index a3a28df04d..09138f41c2 100644
--- a/framework_crates/bones_framework/src/render/tilemap.rs
+++ b/framework_crates/bones_framework/src/render/tilemap.rs
@@ -10,8 +10,6 @@ pub struct EntityGridMap {
     pub tiles: Vec<Option<Entity>>,
     /// The size of the map in tiles (or columns and rows).
     pub grid_size: UVec2,
-    /// The size of each tile in the layer.
-    pub tile_size: Vec2,
 }
 
 /// A tilemap layer component.
@@ -25,9 +23,9 @@ pub struct TileLayer {
 }
 impl TileLayer {
     /// Create a new [`TileLayer`].
-    pub fn new(grid_size: UVec2, tile_size: Vec2, atlas: Handle<Atlas>) -> Self {
+    pub fn new(grid_size: UVec2, atlas: Handle<Atlas>) -> Self {
         Self {
-            map: EntityGridMap::new(grid_size, tile_size),
+            map: EntityGridMap::new(grid_size),
             atlas,
         }
     }
@@ -47,21 +45,15 @@ pub struct Tile {
 
 impl EntityGridMap {
     /// Create a new tile layer
-    pub fn new(grid_size: UVec2, tile_size: Vec2) -> Self {
+    pub fn new(grid_size: UVec2) -> Self {
         let mut out = Self {
             tiles: Vec::new(),
             grid_size,
-            tile_size,
         };
         out.ensure_space();
         out
     }
 
-    /// Get the overall world size
-    pub fn size(&self) -> Vec2 {
-        self.grid_size.as_vec2() * self.tile_size
-    }
-
     /// Get's the entity at the given position in the grid if set, indexed with
     /// the bottom-left of the grid being (0, 0).
     ///
@@ -188,7 +180,7 @@ impl EntityGridMap {
     /// If shrinking the layer, tiles that are out-of-bounds will be removed.
     pub fn resize_grid(&mut self, grid_size: UVec2) {
         // Create a new layer with the desired grid size
-        let mut new_layer = EntityGridMap::new(grid_size, self.tile_size);
+        let mut new_layer = EntityGridMap::new(grid_size);
 
         // Copy the tiles from this layer into the new one
         new_layer.copy_from(self);

From b25188259883eed025c5d50c4a368d4a25a68321 Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Sat, 12 Sep 2026 14:24:05 -0500
Subject: [PATCH 33/36] feat!: add `CoreStage::StartupResource` which runs
 before `CoreStage::Startup` and is now the stage used in
 `add_startup_resource` and `init_startup_resource`.

---
 framework_crates/bones_ecs/src/stage.rs | 56 +++++++++++++++++--------
 1 file changed, 38 insertions(+), 18 deletions(-)

diff --git a/framework_crates/bones_ecs/src/stage.rs b/framework_crates/bones_ecs/src/stage.rs
index 17d11daa33..d5ea5048ea 100644
--- a/framework_crates/bones_ecs/src/stage.rs
+++ b/framework_crates/bones_ecs/src/stage.rs
@@ -1,6 +1,7 @@
 //! Implementation of stage abstraction for running collections of systems over a [`World`].
 
 use std::collections::VecDeque;
+use std::marker::PhantomData;
 
 use crate::prelude::*;
 
@@ -21,7 +22,14 @@ impl SystemStages {
     pub fn with_core_stages() -> Self {
         Self {
             stages: vec![
-                Box::new(StartupSystemStage::new(CoreStage::Startup)),
+                Box::new(
+                    StartupSystemStage::<CoreStageStartupResourceSystemsRan>::new(
+                        CoreStage::StartupResource,
+                    ),
+                ),
+                Box::new(StartupSystemStage::<CoreStageStartupSystemsRan>::new(
+                    CoreStage::Startup,
+                )),
                 Box::new(SimpleSystemStage::new(CoreStage::First)),
                 Box::new(SimpleSystemStage::new(CoreStage::PreUpdate)),
                 Box::new(SimpleSystemStage::new(CoreStage::Update)),
@@ -127,16 +135,16 @@ impl SystemStages {
     /// Adds a system to [`CoreStage::Startup`] that inserts the default value
     /// of a resource into the [`World`] if it doesn't already exist.
     pub fn init_startup_resource<R: HasSchema + FromWorld>(&mut self) -> &mut Self {
-        self.add_system_to_stage(Startup, |world: &World| {
+        self.add_system_to_stage(StartupResource, |world: &World| {
             world.init_resource::<R>();
         });
         self
     }
 
-    /// Adds a system to [`CoreStage::Startup`] that inserts the given resource
-    /// into the [`World`] if it doesn't already exist. The resource type is
-    /// required to have a [`HasSchema`] clone implementation to re-insert the
-    /// resource into the world after the first startup.
+    /// Adds a system to [`CoreStage::StartupResource`] that inserts the given
+    /// resource into the [`World`] if it doesn't already exist. The resource
+    /// type is required to have a [`HasSchema`] clone implementation to
+    /// re-insert the resource into the world after the first startup.
     ///
     /// # Clone Requirement Details
     /// If the type being added implements [`HasSchema`] with the derive like
@@ -146,14 +154,16 @@ impl SystemStages {
     /// #[schema(no_clone)] // This bypasses HasSchema clone requirements.
     /// struct ResourceBeingInserted;
     /// ```
-    /// Then the system being added to the [`Startup`] system stage will panic
-    /// when inserting a second time. The startup stage only runs once so it is
-    /// therefore safe to use a type like the example above as long as you don't
-    /// plan on removing the [`StartupSystemsRan`] resource from the [`World`].
+    /// Then the system being added to the [`StartupResource`] system stage will
+    /// panic when inserting a second time. The startup resource stage only runs
+    /// once so it is therefore safe to use a type like the example above as
+    /// long as you don't plan on removing from the [`World`] the
+    /// [`StartupSystemStage`] tag which in this case is
+    /// [`CoreStageStartupResourceSystemsRan`].
     pub fn add_startup_resource<R: HasSchema>(&mut self, resource: R) -> &mut Self {
         let mut once = Some(SchemaBox::new(resource));
 
-        self.add_system_to_stage(Startup, move |world: &World| {
+        self.add_system_to_stage(StartupResource, move |world: &World| {
             if !world.resources.contains::<R>() {
                 let schema_box = if R::schema().clone_fn.is_some() {
                     once.clone()
@@ -264,12 +274,17 @@ impl SystemStage for SimpleSystemStage {
 }
 
 /// Resource for tracking whether or not the game has run the startup systems in
-/// the [`StartupSystemStage`].
+/// [`CoreStage::Startup`].
 #[derive(HasSchema, Clone, Default, Debug)]
-pub struct StartupSystemsRan;
+pub struct CoreStageStartupSystemsRan;
+
+/// Resource for tracking whether or not the game has run the startup systems in
+/// [`CoreStage::StartupResource`].
+#[derive(HasSchema, Clone, Default, Debug)]
+pub struct CoreStageStartupResourceSystemsRan;
 
 /// [`SystemStage`] for running systems once on startup.
-pub struct StartupSystemStage {
+pub struct StartupSystemStage<T: HasSchema + Default + Clone> {
     /// The unique identifier for the stage.
     pub id: Ulid,
     /// The human-readable name for the stage, used for error messages when something goes wrong.
@@ -278,18 +293,20 @@ pub struct StartupSystemStage {
     ///
     /// Each system will be run in the order that they are in in this list.
     pub systems: Vec<StaticSystem<(), ()>>,
+    _phantom_data: PhantomData<T>,
 }
-impl StartupSystemStage {
+impl<T: HasSchema + Clone + Default> StartupSystemStage<T> {
     /// Create a new, empty stage, for the given label.
     pub fn new<L: StageLabel>(label: L) -> Self {
         Self {
             id: label.id(),
             name: label.name(),
             systems: Default::default(),
+            _phantom_data: PhantomData,
         }
     }
 }
-impl SystemStage for StartupSystemStage {
+impl<T: HasSchema + Clone + Default> SystemStage for StartupSystemStage<T> {
     fn id(&self) -> Ulid {
         self.id
     }
@@ -299,12 +316,12 @@ impl SystemStage for StartupSystemStage {
     }
 
     fn run(&mut self, world: &World) {
-        if world.get_resource_mut::<StartupSystemsRan>().is_none() {
+        if world.get_resource_mut::<T>().is_none() {
             // Run the systems
             for system in &mut self.systems {
                 system.run(world, ());
             }
-            world.insert_resource(StartupSystemsRan);
+            world.insert_resource(T::default());
         }
 
         // Drain the command queue
@@ -392,6 +409,8 @@ pub trait StageLabel {
 /// A [`StageLabel`] for the 5 core stages.
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum CoreStage {
+    /// The startup resource insertion stage
+    StartupResource,
     /// The startup stage
     Startup,
     /// The first stage
@@ -413,6 +432,7 @@ impl StageLabel for CoreStage {
 
     fn id(&self) -> Ulid {
         match self {
+            CoreStage::StartupResource => Ulid(2162940536129995539438442124983465554),
             CoreStage::Startup => Ulid(2149923225027836290977818907354065512),
             CoreStage::First => Ulid(2021715391084198804812356024998495966),
             CoreStage::PreUpdate => Ulid(2021715401330719559452824437611089988),

From 89b71c15042fde9bc0e6943e2cbb0e678e502dde Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Sat, 10 Oct 2026 19:37:49 -0500
Subject: [PATCH 34/36] fix: rename doc reference

---
 framework_crates/bones_ecs/src/stage.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/framework_crates/bones_ecs/src/stage.rs b/framework_crates/bones_ecs/src/stage.rs
index d5ea5048ea..0d5fe5be87 100644
--- a/framework_crates/bones_ecs/src/stage.rs
+++ b/framework_crates/bones_ecs/src/stage.rs
@@ -107,7 +107,7 @@ impl SystemStages {
     }
 
     /// Add a system to the [`CoreStage::Startup`] stage which specially runs
-    /// only once, before all other core stages. Inserting [`StartupSystemsRan`]
+    /// only once, before all other core stages. Inserting [`CoreStageStartupSystemsRan`]
     /// into the world prevents systems in the startup stage from running.
     #[deprecated = "use `.add_system_to_stage(CoreStage::Startup, your_system)` instead"]
     pub fn add_startup_system<Args, S>(&mut self, system: S) -> &mut Self

From 59ca10c7cb45bcb38e8ed2113ed06dd79a0a7adc Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Sat, 10 Oct 2026 19:38:59 -0500
Subject: [PATCH 35/36] doc: remove unfinished sentence

---
 framework_crates/bones_ecs/src/stage.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/framework_crates/bones_ecs/src/stage.rs b/framework_crates/bones_ecs/src/stage.rs
index 0d5fe5be87..1a10246220 100644
--- a/framework_crates/bones_ecs/src/stage.rs
+++ b/framework_crates/bones_ecs/src/stage.rs
@@ -202,7 +202,7 @@ impl std::fmt::Debug for SystemStages {
     }
 }
 
-/// Trait for system stages. A stage is a
+/// Trait for system stages.
 pub trait SystemStage: Sync + Send {
     /// The unique identifier for the stage.
     fn id(&self) -> Ulid;

From 788a258949a1c88dc45a0e6293d0a836fc609204 Mon Sep 17 00:00:00 2001
From: Tekhnae Raav <tekhnaeraav@katharostech.com>
Date: Sat, 10 Oct 2026 19:46:51 -0500
Subject: [PATCH 36/36] fix!: remove need for Ulid when creating a single
 success system. Fixes a determinism problem in the tests with generating
 Ulids. Uses a static number in the background incremented with each call to
 the wrapper function. This means you can no longer keep track of custom
 specified systems of this kind, but if the case requires it you should be
 using a different system. I also removed the helper systems on the
 SingleSuccessSystems resource since users won't need them. As a user you can
 still reset all systems though by removing the resource.

---
 framework_crates/bones_ecs/src/stage.rs       | 57 ++++++-------------
 .../bones_framework/tests/reset.rs            |  6 +-
 2 files changed, 19 insertions(+), 44 deletions(-)

diff --git a/framework_crates/bones_ecs/src/stage.rs b/framework_crates/bones_ecs/src/stage.rs
index 1a10246220..a87e7102ea 100644
--- a/framework_crates/bones_ecs/src/stage.rs
+++ b/framework_crates/bones_ecs/src/stage.rs
@@ -123,12 +123,12 @@ impl SystemStages {
     /// [`CoreStage::First`].
     ///
     /// See also the wrapper function used inside [`single_success_system`].
-    #[deprecated = "use `.add_system_to_stage(First, single_success_system(Ulid::new(), your_system)"]
+    #[deprecated = "use `.add_system_to_stage(First, single_success_system(your_system)"]
     pub fn add_single_success_system<Args, S>(&mut self, system: S) -> &mut Self
     where
         S: IntoSystem<Args, (), Option<()>, Sys = StaticSystem<(), Option<()>>>,
     {
-        self.add_system_to_stage(First, single_success_system(Ulid::new(), system));
+        self.add_system_to_stage(First, single_success_system(system));
         self
     }
 
@@ -347,56 +347,31 @@ impl<T: HasSchema + Clone + Default> SystemStage for StartupSystemStage<T> {
 /// Runs the given system each frame until it succeeds (returns Some). Uses
 /// `Option<()>` instead of a `bool` to allow for easy usage of `?`.
 ///
-/// Takes a [`Ulid`] that is used to identify whether or not the system has
-/// succeeded from the [`SingleSuccessSystems`] resource.
-pub fn single_success_system<Args, S>(id: Ulid, system: S) -> StaticSystem<(), ()>
+/// System success is tracked with the [`SingleSuccessSystems`] resource which
+/// can be removed if you wish to let all single success systems run again.
+pub fn single_success_system<Args, S>(system: S) -> StaticSystem<(), ()>
 where
     S: IntoSystem<Args, (), Option<()>, Sys = StaticSystem<(), Option<()>>>,
 {
+    use std::sync::atomic::{AtomicU64, Ordering};
+    static SINGLE_SUCCESS_SYSTEM_ID_GEN: AtomicU64 = AtomicU64::new(0);
+
+    let id = SINGLE_SUCCESS_SYSTEM_ID_GEN.fetch_add(1, Ordering::SeqCst);
     let mut system = system.system();
     (move |world: &World| {
-        let succeeded = world
-            .init_resource::<SingleSuccessSystems>()
-            .has_system_succeeded(id);
-        if !succeeded && system.run(world, ()).is_some() {
-            world
-                .init_resource::<SingleSuccessSystems>()
-                .set_system_completed(id);
+        if !world.init_resource::<SingleSuccessSystems>().contains(&id)
+            && system.run(world, ()).is_some()
+        {
+            world.init_resource::<SingleSuccessSystems>().insert(id);
         }
     })
     .system()
 }
 
-// TODO: Figure out a name for a function that creates a single success system
-// with the Ulid created automatically internally. Maybe rename the current
-// function to something else and have the auto-generated id function as
-// standard since there is probably only a slim possibility that you will need
-// to re-use a Ulid for these kind of systems.
-
-/// Resource tracking which of single success systems have completed with a
-/// [`HashSet`] of [`Ulid`] for the succeeded.
+/// Resource tracking which single success systems have completed using a
+/// [`HashSet`] of unique [`u64`]s for the succeeded.
 #[derive(HasSchema, Clone, Default, Deref, DerefMut)]
-pub struct SingleSuccessSystems(pub HashSet<Ulid>);
-
-impl SingleSuccessSystems {
-    /// Reset single success systems completion status. so they run again until success.
-    #[inline]
-    pub fn reset(&mut self) {
-        self.clear();
-    }
-
-    /// Check if system has completed
-    #[inline]
-    pub fn has_system_succeeded(&self, ulid: Ulid) -> bool {
-        self.contains(&ulid)
-    }
-
-    /// Mark system as completed.
-    #[inline]
-    pub fn set_system_completed(&mut self, ulid: Ulid) {
-        self.insert(ulid);
-    }
-}
+pub struct SingleSuccessSystems(pub HashSet<u64>);
 
 /// Trait for things that may be used to identify a system stage.
 pub trait StageLabel {
diff --git a/framework_crates/bones_framework/tests/reset.rs b/framework_crates/bones_framework/tests/reset.rs
index 4b8087f8d1..0eb6f77ac8 100644
--- a/framework_crates/bones_framework/tests/reset.rs
+++ b/framework_crates/bones_framework/tests/reset.rs
@@ -26,8 +26,8 @@ pub fn startup_system_reset() {
     assert_eq!(game.shared_resource::<Counter>().0, 1);
 
     // Reset the world; Equivalent to reseting at the start or end of the frame.
-    // `StartupSystemsRan` is inserted into the world to indicate completion,
-    // but is not kept so startup systems should run again.
+    // `CoreStageStartupSystemsRan` is inserted into the world to indicate
+    // completion, but is not kept so startup systems should run again.
     ResetWorld::standard().reset(&game.sessions.get_mut("game").unwrap().world);
 
     // step again to trigger startup
@@ -52,7 +52,7 @@ pub fn single_success_system_reset() {
         // Single success system increments counter by 1 until 2.
         .add_system_to_stage(
             First,
-            single_success_system(Ulid::new(), |mut counter: ResMut<Counter>| -> Option<()> {
+            single_success_system(|mut counter: ResMut<Counter>| -> Option<()> {
                 // Increment until 2
                 counter.0 += 1;
                 if counter.0 >= 2 {