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 51e4380b9d..b7ac675f39 100644
--- a/demos/features/src/main.rs
+++ b/demos/features/src/main.rs
@@ -139,18 +139,18 @@ 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
         .add_system_to_stage(Update, menu_system)
-        .add_startup_system(menu_startup);
+        .add_system_to_stage(CoreStage::Startup, menu_startup);
 }
 
 /// Setup the main menu.
@@ -280,10 +280,10 @@ 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_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);
 }
@@ -344,10 +344,10 @@ 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_startup_system(tilemap_startup_system)
+        .add_system_to_stage(CoreStage::Startup, tilemap_startup_system)
         .add_system_to_stage(Update, back_to_menu_ui);
 }
 
@@ -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 {
@@ -390,10 +389,10 @@ 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_startup_system(atlas_demo_startup)
+        .add_system_to_stage(CoreStage::Startup, atlas_demo_startup)
         .add_system_to_stage(Update, back_to_menu_ui);
 }
 
@@ -438,7 +437,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 +463,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,10 +493,10 @@ fn storage_demo_ui(
     });
 }
 
-fn path2d_demo_plugin(session: &mut SessionBuilder) {
+fn path2d_demo_plugin(session: &mut Session) {
     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/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/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..fb81cce18d 100644
--- a/demos/scripting/src/main.rs
+++ b/demos/scripting/src/main.rs
@@ -19,12 +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);
-        });
+        .create("launch")
+        .add_system_to_stage(CoreStage::Startup, launch_game_session);
 
     let mut renderer = BonesBevyRenderer::new(game);
     renderer.app_namespace = (
@@ -42,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_startup_system(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_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<'_>,
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_ecs/examples/pos_vel.rs b/framework_crates/bones_ecs/examples/pos_vel.rs
index 6d4f52ea2d..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
-        .add_startup_system(startup_system)
+    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/resources.rs b/framework_crates/bones_ecs/src/resources.rs
index 175f9030b0..c76f82dc2c 100644
--- a/framework_crates/bones_ecs/src/resources.rs
+++ b/framework_crates/bones_ecs/src/resources.rs
@@ -201,9 +201,40 @@ 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(&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 +328,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();
     }
 }
 
@@ -547,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());
 
@@ -604,7 +635,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/stage.rs b/framework_crates/bones_ecs/src/stage.rs
index f5a4db2c86..a87e7102ea 100644
--- a/framework_crates/bones_ecs/src/stage.rs
+++ b/framework_crates/bones_ecs/src/stage.rs
@@ -1,93 +1,44 @@
 //! Implementation of stage abstraction for running collections of systems over a [`World`].
 
 use std::collections::VecDeque;
+use std::marker::PhantomData;
 
 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.
-#[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>>,
-    /// 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,
-
-    /// 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 {
+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![
+                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)),
                 Box::new(SimpleSystemStage::new(CoreStage::PostUpdate)),
                 Box::new(SimpleSystemStage::new(CoreStage::Last)),
             ],
-            startup_resources: default(),
-            startup_systems: default(),
-            single_success_systems: Vec::new(),
-        }
-    }
-
-    /// Finish building and convert to [`SystemStages`]
-    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,
         }
     }
 
-    /// Create [`SystemStagesBuilder`] by taking existing [`SystemStages`].
-    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.
-    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 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
@@ -146,221 +97,112 @@ 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>>,
-
-    /// 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,
-
-    /// 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 {
-    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) {
-        // If we haven't run startup systems and setup resources yet, do so
-        self.handle_startup(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
-            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>();
     }
 
-    /// 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);
+    /// Add a system to the [`CoreStage::Startup`] stage which specially runs
+    /// 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
+    where
+        S: IntoSystem<Args, (), (), Sys = StaticSystem<(), ()>>,
+    {
+        self.add_system_to_stage(CoreStage::Startup, system.system());
+        self
     }
 
-    /// If [`SessionStarted`] resource indicates startup resources have not yet been inserted, will do so and update `SessionStarted`.
+    /// 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`].
     ///
-    /// 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).
-    ///
-    /// # 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),
-        };
-
-        if !resources_inserted {
-            self.insert_startup_resources(world);
-            resources_inserted = true;
+    /// See also the wrapper function used inside [`single_success_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(system));
+        self
+    }
 
-            world.insert_resource(SessionStarted {
-                startup_systems_executed: systems_run,
-                startup_resources_inserted: resources_inserted,
-            });
-        }
+    /// 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(StartupResource, |world: &World| {
+            world.init_resource::<R>();
+        });
+        self
     }
 
-    /// 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
+    /// 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.
     ///
-    /// 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, ());
+    /// # 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 [`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(StartupResource, 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()
+                    )
+                };
             }
-            systems_run = true;
-
-            world.resources.remove::<CurrentSystemStage>();
-            world.insert_resource(SessionStarted {
-                startup_systems_executed: systems_run,
-                startup_resources_inserted: resources_inserted,
-            });
-        }
-    }
-
-    /// 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);
+        });
+        self
     }
+}
 
-    /// 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`.");
-            }
-        }
+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
+/// Trait for system stages.
 pub trait SystemStage: Sync + Send {
     /// The unique identifier for the stage.
     fn id(&self) -> Ulid;
@@ -431,6 +273,106 @@ impl SystemStage for SimpleSystemStage {
     }
 }
 
+/// Resource for tracking whether or not the game has run the startup systems in
+/// [`CoreStage::Startup`].
+#[derive(HasSchema, Clone, Default, Debug)]
+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<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.
+    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<(), ()>>,
+    _phantom_data: PhantomData<T>,
+}
+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<T: HasSchema + Clone + Default> SystemStage for StartupSystemStage<T> {
+    fn id(&self) -> Ulid {
+        self.id
+    }
+
+    fn name(&self) -> String {
+        self.name.clone()
+    }
+
+    fn run(&mut self, world: &World) {
+        if world.get_resource_mut::<T>().is_none() {
+            // Run the systems
+            for system in &mut self.systems {
+                system.run(world, ());
+            }
+            world.insert_resource(T::default());
+        }
+
+        // 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();
+    }
+}
+
+/// 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 `?`.
+///
+/// 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| {
+        if !world.init_resource::<SingleSuccessSystems>().contains(&id)
+            && system.run(world, ()).is_some()
+        {
+            world.init_resource::<SingleSuccessSystems>().insert(id);
+        }
+    })
+    .system()
+}
+
+/// 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<u64>);
+
 /// 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 +384,10 @@ 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
     First,
     /// The second stage
@@ -461,6 +407,8 @@ 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),
             CoreStage::Update => Ulid(2021715410160177201728645950400543948),
@@ -525,41 +473,3 @@ impl<'a> SystemParam for Commands<'a> {
         Commands(state.borrow_mut().unwrap())
     }
 }
-
-/// Resource tracking if Session has started (startup systems executed and resources inserted).
-/// 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,
-}
-
-/// 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_ecs/src/world.rs b/framework_crates/bones_ecs/src/world.rs
index 867d3686d4..ebac88d70c 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);
@@ -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)
     }
@@ -183,6 +183,31 @@ 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();
+    }
+
+    /// 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.
@@ -394,7 +419,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/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/input.rs b/framework_crates/bones_framework/src/input.rs
index d87a74837f..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;
-
-    // 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/input/gamepad.rs b/framework_crates/bones_framework/src/input/gamepad.rs
index 399ce61405..1cd07ac1a0 100644
--- a/framework_crates/bones_framework/src/input/gamepad.rs
+++ b/framework_crates/bones_framework/src/input/gamepad.rs
@@ -64,7 +64,19 @@ 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,
+)]
+#[schema(hash, eq)]
 #[repr(C, u8)]
 pub enum GamepadButton {
     #[default]
@@ -135,8 +147,10 @@ pub struct GamepadAxisEvent {
 }
 
 /// A specific gamepad axis that may have changed.
-#[derive(HasSchema, Clone, Copy, Debug, PartialEq, Eq, Hash)]
-#[schema(no_default)]
+#[derive(
+    HasSchema, Clone, Copy, Debug, PartialEq, Eq, Hash, serde::Deserialize, serde::Serialize,
+)]
+#[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..12d66afadb 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"),
     )))
@@ -39,7 +39,6 @@ pub fn process_gamepad_events() -> GamepadInputs {
         let gamepad = usize::from(gilrs_event.id) as u32;
         match gilrs_event.event {
             EventType::Connected => {
-                let _pad = gilrs.gamepad(gilrs_event.id);
                 gamepad_inputs.gamepad_events.push(GamepadEvent::Connection(
                     GamepadConnectionEvent {
                         gamepad,
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]
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]
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 b7953687b1..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
@@ -838,12 +842,12 @@ where
 
                                     {
                                         world
-                                            .resource_mut::<Time>()
+                                            .init_resource::<Time>()
                                             .advance_exact(Duration::from_secs_f64(step));
 
                                         // 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()
                                         {
@@ -862,22 +866,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.handle_world_reset(stages);
-                                    }
                                 }
                             }
                         }
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/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()
-    }
 }
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..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,
@@ -125,7 +124,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/tilemap.rs b/framework_crates/bones_framework/src/render/tilemap.rs
index 2da156303b..09138f41c2 100644
--- a/framework_crates/bones_framework/src/render/tilemap.rs
+++ b/framework_crates/bones_framework/src/render/tilemap.rs
@@ -2,18 +2,34 @@
 
 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, atlas: Handle<Atlas>) -> Self {
+        Self {
+            map: EntityGridMap::new(grid_size),
+            atlas,
+        }
+    }
+}
 
 /// A tilemap tile component.
 #[derive(Clone, Debug, HasSchema, Default)]
@@ -27,60 +43,151 @@ 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) -> 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;
-
-        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);
+
+        // 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
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 698730c398..0eb6f77ac8 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_startup_system(|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
@@ -26,18 +25,10 @@ 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
-    {
-        let game_session = game.sessions.get_mut("game").unwrap();
-        game_session.world.init_resource::<CommandQueue>().add(
-            |mut reset: ResMutInit<ResetWorld>| {
-                reset.reset = true;
-            },
-        );
-    }
-
-    // step again, world should be reset. Startup doesn't run until next step though.
-    game.step(Instant::now());
+    // Reset the world; Equivalent to reseting at the start or end of the frame.
+    // `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
     game.step(Instant::now());
@@ -52,16 +43,16 @@ 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<()> {
+        .create("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(|mut counter: ResMut<Counter>| -> Option<()> {
                 // Increment until 2
                 counter.0 += 1;
                 if counter.0 >= 2 {
@@ -69,47 +60,48 @@ pub fn single_success_system_reset() {
                 }
 
                 None
-            });
-        });
+            }),
+        );
 
     // Step three times, single success should've incremented counter to 2 and completed.
     game.step(Instant::now());
     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
-    {
-        let game_session = game.sessions.get_mut("game").unwrap();
-        game_session.world.init_resource::<CommandQueue>().add(
-            |mut reset: ResMutInit<ResetWorld>| {
-                reset.reset = true;
-            },
-        );
-    }
+    // Reset the world; Equivalent to reseting at the start or end of the frame.
+    ResetWorld::standard().reset(&game.sessions.get_mut("game").unwrap().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 +112,79 @@ 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_keep_and_drop() {
     let mut game = Game::new();
 
-    // insert counter resource
     game.sessions
-        .create_with("game", |builder: &mut SessionBuilder| {
-            builder.init_resource::<Counter>();
-        });
+        .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 that the resources were inserted on startup
     {
-        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 boolean = world.get_resource::<bool>().unwrap();
+        assert!(boolean == false); // false is boolean default
     }
 
-    // Add command that will trigger reset on next step,
-    // and add reset resource of Counter with value 1
+    // keep resources & reset world
     {
-        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;
+
+        // 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);
     }
 
-    // Step to reset
-    game.step(Instant::now());
+    // verify Counter is 3 and boolean type is gone
     {
-        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;
 
-#[test]
-pub fn reset_world_emtpy_resource() {
-    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| {
-            builder.init_resource::<Counter>();
-        });
+        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());
-    {
-        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>();
-            },
-        );
-    }
+        let world = &game.sessions.get("game").unwrap().world;
 
-    // Step to reset
-    game.step(Instant::now());
-    {
-        let session = game.sessions.get("game").unwrap();
-        let counter = session.world.get_resource::<Counter>();
+        let counter = world.get_resource::<Counter>().unwrap();
+        assert_eq!(counter.0, 3);
 
-        // Verify resource was removed instead of reseting to initial state of session build.
-        assert!(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_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 8f28f5e915..0b779f1175 100644
--- a/framework_crates/bones_lib/src/lib.rs
+++ b/framework_crates/bones_lib/src/lib.rs
@@ -12,7 +12,7 @@ pub use bones_ecs as ecs;
 pub mod prelude {
     pub use crate::{
         ecs::prelude::*, instant::Instant, reset::*, time::*, Game, GamePlugin, Session,
-        SessionBuilder, SessionCommand, SessionOptions, SessionPlugin, SessionRunner, Sessions,
+        SessionCommand, SessionOptions, SessionPlugin, SessionRunner, Sessions,
     };
     pub use ustr::{ustr, Ustr, UstrMap, UstrSet};
 }
@@ -26,13 +26,17 @@ 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,
+/// 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 {
+    /// 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.
@@ -41,223 +45,67 @@ 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(),
             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),
-            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 {
+impl Session {
+    /// 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
     }
-
-    /// 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.stages.insert_startup_resource(resource);
+    /// Set the [`SessionRunner`] to use for this session.
+    pub fn runner(&mut self, runner: Box<dyn SessionRunner>) -> &mut Self {
+        self.runner = runner;
         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.stages.init_startup_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>()
-    }
-
-    /// 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.
-    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());
+    /// 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
     }
-
-    /// 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.stages.add_single_success_system(system.system());
+    /// Set whether or not this session should be rendered.
+    pub fn visibility(&mut self, visible: bool) -> &mut Self {
+        self.visible = visible;
         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);
+    /// Set this session to be rendered.
+    pub fn visible(&mut self) -> &mut Self {
+        self.visible = true;
         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);
+    /// Set this session to not be rendered.
+    pub fn invisible(&mut self) -> &mut Self {
+        self.visible = false;
         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);
-
+    /// Set this session to have it's systems run.
+    pub fn active(&mut self) -> &mut Self {
+        self.active = true;
         self
     }
-
-    /// Set the session runner for this session.
-    pub fn set_session_runner(&mut self, runner: Box<dyn SessionRunner>) {
-        self.runner = runner;
+    /// Set this session to not have it's systems run.
+    pub fn inactive(&mut self) -> &mut Self {
+        self.active = false;
+        self
     }
-
-    /// Install a plugin.
+    /// Install a [`SessionPlugin`].
     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 mut w = World::default();
-                w.init_resource::<Time>();
-                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.
-        // Startup systems are deferred until first step of stages.
-        session.stages.handle_startup_resources(&mut session.world);
-
-        sessions.add(self.name, session)
-    }
-}
-
-/// 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.")
-        }
-    }
-}
-
-/// 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 {
@@ -273,37 +121,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)
     }
 }
@@ -335,11 +159,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(stages);
-    ///
     /// }
     /// fn restart_session(&mut self) {}
     /// fn disable_local_input(&mut self, disable_input: bool) {}
@@ -362,11 +181,8 @@ 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);
-
-        // Checks if reset of world has been triggered by [`ResetWorld`] and handles a reset.
-        world.handle_world_reset(stages);
     }
 
     // This is a no-op as no state, but implemented this way in case that changes later.
@@ -778,10 +594,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>>,
 }
 
@@ -798,50 +616,36 @@ 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>>(
+    // 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>>(
         &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.
@@ -885,16 +689,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 2a9ddb6a14..a2b1577c7e 100644
--- a/framework_crates/bones_lib/src/reset.rs
+++ b/framework_crates/bones_lib/src/reset.rs
@@ -1,117 +1,75 @@
-//! Extensions of bones_ecs for utility functions in resetting a World
+//! Conveniences for resetting a World to its' default 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 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.
 ///
-/// `reset_world: ResMutInit<ResetWorld>` and setting `reset_world.reset = true;` may be used to trigger a reset from system execution.
-#[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,
-}
+/// 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 {
-    /// 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);
+    /// 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())
     }
-
-    /// 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>()
-    }
-
-    /// 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>();
+    /// Create a [`ResetWorld`] that already keeps some basic special resources
+    /// that are usually needed like [`SessionOptions`] & [`Entities`].
+    pub fn standard() -> Self {
+        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>()
     }
-}
-
-/// 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.
-    ///
-    /// `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);
-
-    /// 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.
-    ///
-    /// `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.
+    /// Adds the [`SchemaId`] of the type given to the set of resources to keep
+    /// on reset.
     ///
-    /// 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);
-}
-
-impl WorldExt for World {
-    fn handle_world_reset(&mut self, stages: &mut SystemStages) {
-        if self.reset_triggered() {
-            self.reset_internals(stages);
-        }
+    /// 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
     }
-
-    fn reset_triggered(&self) -> bool {
-        self.get_resource::<ResetWorld>().is_some_and(|r| r.reset)
+    /// 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.contains(&schema_id));
     }
-
-    fn reset_internals(&mut self, stages: &mut SystemStages) {
-        // 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);
-
-        // 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, 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);
-
-        // 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);
-        }
-
-        // Now run the startup systems after updating resources.
-        stages.handle_startup_systems(self);
+    /// 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_schema/macros/src/lib.rs b/framework_crates/bones_schema/macros/src/lib.rs
index 95dd82f7f8..1da2d43a58 100644
--- a/framework_crates/bones_schema/macros/src/lib.rs
+++ b/framework_crates/bones_schema/macros/src/lib.rs
@@ -15,28 +15,30 @@ 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
-/// 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".
-/// 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)]
-/// 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(C, 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)]
@@ -46,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())]
@@ -78,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)]
@@ -156,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());
 
@@ -170,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 = (|| {
@@ -229,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()),
                                         })
                                     },
@@ -359,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()),
         })
     };
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
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);
diff --git a/framework_crates/bones_scripting/src/lua.rs b/framework_crates/bones_scripting/src/lua.rs
index 414eb27423..a947bb6a12 100644
--- a/framework_crates/bones_scripting/src/lua.rs
+++ b/framework_crates/bones_scripting/src/lua.rs
@@ -47,10 +47,11 @@ 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,
             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)