chore: rename ecs* crates to engine-ecs*

46 files changed, 0 insertions, 9142 deletions

diff --git a/ecs/Cargo.toml b/ecs/Cargo.toml
deleted file mode 100644
index 0a94ff0..0000000
--- a/ecs/Cargo.toml
+++ /dev/null
@@ -1,34 +0,0 @@
-[package]
-name = "ecs"
-version = "0.1.0"
-edition = "2021"
-
-[features]
-vizoxide = ["dep:vizoxide"]
-
-[dependencies]
-seq-macro = "0.3.5"
-paste = "1.0.14"
-thiserror = "1.0.49"
-tracing = "0.1.39"
-hashbrown = "0.15.2"
-parking_lot = "0.12.3"
-anyhow = "1.0.102"
-backtrace = "0.3.76"
-ecs-macros = {  workspace = true  }
-util-macros = {  workspace = true  }
-vizoxide = { version = "1.0.5", optional = true }
-
-[dev-dependencies.criterion]
-version = "0.5.1"
-default-features = false
-features = ["cargo_bench_support"]
-
-[dev-dependencies.tracing-subscriber]
-version = "0.3.17"
-default-features = false
-features = ["std", "ansi", "fmt", "smallvec", "env-filter", "chrono"]
-
-[[bench]]
-name = "query"
-harness = false
diff --git a/ecs/benches/query.rs b/ecs/benches/query.rs
deleted file mode 100644
index f14bb06..0000000
--- a/ecs/benches/query.rs
+++ /dev/null
@@ -1,141 +0,0 @@
-use std::hint::black_box;
-use std::path::PathBuf;
-
-use criterion::{criterion_group, criterion_main, Criterion};
-use ecs::{Component, World};
-
-#[derive(Component)]
-struct Foo
-{
-    _text: String,
-}
-
-#[derive(Component)]
-struct Bar
-{
-    _path: PathBuf,
-    _num: u64,
-}
-
-#[derive(Component)]
-struct Position
-{
-    _x: f32,
-    _y: f32,
-    _z: f32,
-}
-
-#[derive(Component)]
-struct PosA
-{
-    _x: f32,
-    _y: f32,
-    _z: f32,
-}
-
-#[derive(Component)]
-struct PosB
-{
-    _x: f32,
-    _y: f32,
-    _z: f32,
-}
-
-#[derive(Component)]
-struct PosC
-{
-    _x: f32,
-    _y: f32,
-    _z: f32,
-}
-
-#[derive(Component)]
-struct MoreText
-{
-    _more_text: String,
-}
-
-#[derive(Component)]
-struct EvenMoreText
-{
-    _even_more_text: String,
-}
-
-fn spawn_1000_entities(world: &mut World)
-{
-    for _ in 0..300 {
-        world.create_entity((
-            Bar {
-                _path: "/dev/zero".into(),
-                _num: 65789,
-            },
-            Position { _x: 13.98, _y: 27.0, _z: 0.2 },
-            Foo { _text: "Hello there".to_string() },
-            PosA {
-                _x: 1183.98,
-                _y: 272628.0,
-                _z: 3306.2,
-            },
-            PosB {
-                _x: 171183.98,
-                _y: 28.0,
-                _z: 336.2901,
-            },
-            PosC { _x: 8273.98, _y: 28.0, _z: 336.2901 },
-            MoreText {
-                _more_text: "Lorem ipsum".to_string(),
-            },
-            EvenMoreText {
-                _even_more_text: "Wow so much text".to_string(),
-            },
-        ));
-    }
-
-    for _ in 0..700 {
-        world.create_entity((
-            Bar {
-                _path: "/dev/null".into(),
-                _num: 65789,
-            },
-            Position { _x: 88.11, _y: 9.0, _z: 36.11 },
-            Foo { _text: "Hey".to_string() },
-            PosA {
-                _x: 118310.98,
-                _y: 272628.0,
-                _z: 3306.2,
-            },
-            PosB { _x: 11323.98, _y: 28.0, _z: 336.2901 },
-            PosC {
-                _x: 8273.98,
-                _y: 21818.0,
-                _z: 336.2901,
-            },
-            MoreText {
-                _more_text: "Lorem ipsum".to_string(),
-            },
-            EvenMoreText {
-                _even_more_text: "Wow much text".to_string(),
-            },
-        ));
-    }
-}
-
-fn benchbark(criterion: &mut Criterion)
-{
-    criterion.bench_function("Iterate 1000 entities", |bencher| {
-        let mut world = World::new();
-
-        spawn_1000_entities(&mut world);
-
-        let query = world.query::<(&Bar, &Position, &Foo), ()>();
-
-        bencher.iter(|| {
-            for comps in query.iter() {
-                black_box(comps);
-            }
-        })
-    });
-}
-
-criterion_group!(benches, benchbark);
-criterion_main!(benches);
diff --git a/ecs/examples/component_changed_event.rs b/ecs/examples/component_changed_event.rs
deleted file mode 100644
index 2168df0..0000000
--- a/ecs/examples/component_changed_event.rs
+++ /dev/null
@@ -1,78 +0,0 @@
-use ecs::event::component::{Changed, EventMatchExt};
-use ecs::pair::Pair;
-use ecs::phase::UPDATE as UPDATE_PHASE;
-use ecs::system::observer::Observe;
-use ecs::{Component, Query, World};
-
-#[derive(Component)]
-struct SomeData
-{
-    num: u64,
-}
-
-#[derive(Component)]
-struct Greeting
-{
-    greeting: String,
-}
-
-fn say_hello(query: Query<(&SomeData, &mut Greeting)>)
-{
-    for (data, mut greeting) in &query {
-        println!("{}: {}", greeting.greeting, data.num);
-
-        if greeting.greeting == "Good evening" {
-            greeting.greeting = "Good morning".to_string();
-            greeting.set_changed();
-        }
-    }
-}
-
-fn print_changed_greetings(observe: Observe<'_, Pair<Changed, Greeting>>)
-{
-    println!("\nChanged greetings:");
-
-    for evt_match in &observe {
-        let greeting = evt_match.get_ent_target_comp();
-
-        println!("A greeting changed to {}", greeting.greeting);
-    }
-
-    println!("");
-}
-
-fn main()
-{
-    let mut world = World::new();
-
-    world.register_system(*UPDATE_PHASE, say_hello);
-
-    world.register_observer(print_changed_greetings);
-
-    world.create_entity((
-        SomeData { num: 987_654 },
-        Greeting {
-            greeting: "Good afternoon".to_string(),
-        },
-    ));
-
-    world.create_entity((
-        SomeData { num: 345 },
-        Greeting { greeting: "Good evening".to_string() },
-    ));
-
-    world.step();
-
-    world.step();
-
-    for (mut greeting,) in &world.query::<(&mut Greeting,), ()>() {
-        if greeting.greeting == "Good afternoon" {
-            greeting.greeting = "Yo yo".to_string();
-            greeting.set_changed();
-        }
-    }
-
-    world.step();
-
-    world.step();
-}
diff --git a/ecs/examples/component_events.rs b/ecs/examples/component_events.rs
deleted file mode 100644
index 06e7fab..0000000
--- a/ecs/examples/component_events.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-use ecs::actions::Actions;
-use ecs::component::Component;
-use ecs::event::component::{Changed, EventMatchExt, Removed};
-use ecs::pair::Pair;
-use ecs::phase::UPDATE;
-use ecs::system::observer::Observe;
-use ecs::{Component, Query, World};
-
-#[derive(Debug, Component)]
-struct CheeseCrumbs
-{
-    cnt: usize,
-}
-
-#[derive(Debug, Component)]
-struct Cheese
-{
-    name: &'static str,
-}
-
-fn eat_cheese(query: Query<(&Cheese, &mut CheeseCrumbs)>, mut actions: Actions)
-{
-    for (cheese_ent_id, (_, mut cheese_crumbs)) in query.iter_with_euids() {
-        println!("Eating cheese!");
-
-        cheese_crumbs.cnt += 40;
-        cheese_crumbs.set_changed();
-
-        actions.remove_components(cheese_ent_id, [Cheese::id()]);
-    }
-}
-
-fn on_cheese_removed(observe: Observe<Pair<Removed, Cheese>>)
-{
-    for evt_match in &observe {
-        let cheese = evt_match.get_ent_target_comp();
-
-        println!("{} cheese was eaten", cheese.name);
-    }
-}
-
-fn on_cheese_crumbs_changed(observe: Observe<Pair<Changed, CheeseCrumbs>>)
-{
-    for evt_match in &observe {
-        let cheese_crumbs = evt_match.get_ent_target_comp();
-
-        println!("Cheese crumbs count changed to {}", cheese_crumbs.cnt);
-    }
-}
-
-fn main()
-{
-    let mut world = World::new();
-
-    world.register_system(*UPDATE, eat_cheese);
-    world.register_observer(on_cheese_removed);
-    world.register_observer(on_cheese_crumbs_changed);
-
-    world.create_entity((Cheese { name: "Brie" }, CheeseCrumbs { cnt: 0 }));
-    world.create_entity((Cheese { name: "Parmesan" }, CheeseCrumbs { cnt: 0 }));
-    world.create_entity((Cheese { name: "Gouda" }, CheeseCrumbs { cnt: 0 }));
-
-    world.step();
-}
diff --git a/ecs/examples/component_relationship.rs b/ecs/examples/component_relationship.rs
deleted file mode 100644
index e07b214..0000000
--- a/ecs/examples/component_relationship.rs
+++ /dev/null
@@ -1,65 +0,0 @@
-use ecs::pair::Pair;
-use ecs::phase::START as START_PHASE;
-use ecs::{Component, Query, World};
-
-#[derive(Component)]
-struct Person
-{
-    name: String,
-}
-
-fn print_dog_likers(query: Query<(&Person, Pair<Likes, &Dogs>)>)
-{
-    for (person, liked_dogs) in &query {
-        println!(
-            "{} likes {} dogs!",
-            person.name,
-            if liked_dogs.large { "large" } else { "small" },
-        );
-    }
-}
-
-#[derive(Component)]
-struct Likes;
-
-#[derive(Component)]
-struct Cats;
-
-#[derive(Component)]
-struct Dogs
-{
-    large: bool,
-}
-
-fn main()
-{
-    let mut world = World::new();
-
-    world.register_system(*START_PHASE, print_dog_likers);
-
-    world.create_entity((
-        Person { name: "Irving".to_string() },
-        Pair::builder()
-            .relation::<Likes>()
-            .target_as_data(Dogs { large: true })
-            .build(),
-    ));
-
-    world.create_entity((
-        Person { name: "Mark".to_string() },
-        Pair::builder()
-            .relation::<Likes>()
-            .target_as_data(Cats)
-            .build(),
-    ));
-
-    world.create_entity((
-        Person { name: "Helena".to_string() },
-        Pair::builder()
-            .relation::<Likes>()
-            .target_as_data(Dogs { large: false })
-            .build(),
-    ));
-
-    world.step();
-}
diff --git a/ecs/examples/component_removed_event.rs b/ecs/examples/component_removed_event.rs
deleted file mode 100644
index 9b73b1a..0000000
--- a/ecs/examples/component_removed_event.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-use ecs::actions::Actions;
-use ecs::component::Component;
-use ecs::event::component::{EventMatchExt, Removed};
-use ecs::pair::Pair;
-use ecs::phase::UPDATE;
-use ecs::system::observer::Observe;
-use ecs::{Component, Query, World};
-
-#[derive(Debug, Component)]
-struct Cheese
-{
-    name: &'static str,
-}
-
-fn eat_cheese(query: Query<(&Cheese,)>, mut actions: Actions)
-{
-    for (cheese_ent_id, (_,)) in query.iter_with_euids() {
-        println!("Eating cheese!");
-
-        actions.remove_components(cheese_ent_id, [Cheese::id()]);
-    }
-}
-
-fn on_cheese_removed(observe: Observe<Pair<Removed, Cheese>>)
-{
-    for evt_match in &observe {
-        let cheese = evt_match.get_ent_target_comp();
-
-        println!("{} cheese was eaten", cheese.name);
-    }
-}
-
-fn main()
-{
-    let mut world = World::new();
-
-    world.register_system(*UPDATE, eat_cheese);
-    world.register_observer(on_cheese_removed);
-
-    world.create_entity((Cheese { name: "Brie" },));
-    world.create_entity((Cheese { name: "Parmesan" },));
-    world.create_entity((Cheese { name: "Gouda" },));
-
-    world.step();
-    world.step();
-}
diff --git a/ecs/examples/error_handling.rs b/ecs/examples/error_handling.rs
deleted file mode 100644
index dc34c5f..0000000
--- a/ecs/examples/error_handling.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-use ecs::error::Error;
-use ecs::event::component::{Changed, EventMatchExt};
-use ecs::pair::Pair;
-use ecs::phase::UPDATE;
-use ecs::query::Query;
-use ecs::system::observer::Observe;
-use ecs::{Component, World, error};
-use tracing::level_filters::LevelFilter;
-use tracing_subscriber::EnvFilter;
-use tracing_subscriber::fmt::time::ChronoLocal;
-use tracing_subscriber::layer::SubscriberExt;
-use tracing_subscriber::util::SubscriberInitExt;
-
-#[derive(Component)]
-struct State
-{
-    value: u32,
-}
-
-fn do_something_fallible(query: Query<(&mut State,)>) -> Result<(), Error>
-{
-    for (mut state,) in &query {
-        state.value += 1;
-
-        state.set_changed();
-
-        if state.value > 3 {
-            return Err(error!("Invalid state value {}", state.value));
-        }
-    }
-
-    Ok(())
-}
-
-fn handle_state_changed(observe: Observe<Pair<Changed, State>>) -> Result<(), Error>
-{
-    for evt_match in &observe {
-        let state = evt_match.get_ent_target_comp();
-
-        if state.value > 3 {
-            return Err(error!("Invalid state value {}", state.value));
-        }
-
-        tracing::info!("State has valid value {}", state.value);
-    }
-
-    Ok(())
-}
-
-fn main()
-{
-    tracing_subscriber::registry()
-        .with(
-            tracing_subscriber::fmt::layer()
-                .with_timer(ChronoLocal::new("%T%.6f".to_string())),
-        )
-        .with(
-            EnvFilter::builder()
-                .with_default_directive(LevelFilter::DEBUG.into())
-                .from_env()
-                .unwrap(),
-        )
-        .init();
-
-    let mut world = World::new();
-
-    world.set_err_handler(ecs::error::err_handler_log_error);
-
-    world.create_entity((State { value: 0 },));
-
-    world.register_system(*UPDATE, do_something_fallible);
-
-    world.register_observer(handle_state_changed);
-
-    world.step();
-    world.step();
-    world.step();
-    world.step();
-}
diff --git a/ecs/examples/event_loop.rs b/ecs/examples/event_loop.rs
deleted file mode 100644
index bec2c00..0000000
--- a/ecs/examples/event_loop.rs
+++ /dev/null
@@ -1,120 +0,0 @@
-use ecs::actions::Actions;
-use ecs::pair::{ChildOf, Pair};
-use ecs::phase::{Phase, UPDATE as UPDATE_PHASE};
-use ecs::{declare_entity, Component, Query, World};
-
-#[derive(Component)]
-struct Wool
-{
-    remaining: u32,
-}
-
-#[derive(Component)]
-struct Health
-{
-    health: u32,
-}
-
-#[derive(Component)]
-struct Name
-{
-    name: &'static str,
-}
-
-fn sheer(query: Query<(&mut Wool, &Name)>)
-{
-    for (mut wool, name) in &query {
-        if wool.remaining == 0 {
-            println!("{} Has no wool left", name.name);
-
-            continue;
-        }
-
-        // Sheer the whool
-        wool.remaining -= 5;
-
-        println!("Sheered 5 wool from {}", name.name);
-    }
-}
-
-fn feed(query: Query<(&mut Health, &Name)>)
-{
-    for (mut health, name) in &query {
-        health.health += 1;
-
-        println!("Feeded {} which gained 1 health", name.name);
-    }
-}
-
-fn age(query: Query<(&mut Health, &Name)>, mut actions: Actions)
-{
-    for (mut health, name) in &query {
-        if health.health <= 2 {
-            health.health = 0;
-
-            println!("{} passed away", name.name);
-
-            actions.stop();
-
-            continue;
-        }
-
-        health.health -= 2;
-
-        println!("{} aged and lost 2 health", name.name);
-    }
-}
-
-declare_entity!(
-    SHEER_PHASE,
-    (
-        Phase,
-        Pair::builder()
-            .relation::<ChildOf>()
-            .target_id(*UPDATE_PHASE)
-            .build()
-    )
-);
-
-declare_entity!(
-    FEED_PHASE,
-    (
-        Phase,
-        Pair::builder()
-            .relation::<ChildOf>()
-            .target_id(*SHEER_PHASE)
-            .build()
-    )
-);
-
-declare_entity!(
-    AGE_PHASE,
-    (
-        Phase,
-        Pair::builder()
-            .relation::<ChildOf>()
-            .target_id(*FEED_PHASE)
-            .build()
-    )
-);
-
-fn main()
-{
-    let mut world = World::new();
-
-    world.create_declared_entity(&SHEER_PHASE);
-    world.create_declared_entity(&FEED_PHASE);
-    world.create_declared_entity(&AGE_PHASE);
-
-    world.register_system(*SHEER_PHASE, sheer);
-    world.register_system(*FEED_PHASE, feed);
-    world.register_system(*AGE_PHASE, age);
-
-    world.create_entity((
-        Wool { remaining: 30 },
-        Health { health: 3 },
-        Name { name: "Bessy" },
-    ));
-
-    world.start_loop();
-}
diff --git a/ecs/examples/extension.rs b/ecs/examples/extension.rs
deleted file mode 100644
index f6282e1..0000000
--- a/ecs/examples/extension.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-use ecs::actions::Actions;
-use ecs::extension::{Collector as ExtensionCollector, Extension};
-use ecs::phase::UPDATE as UPDATE_PHASE;
-use ecs::{Component, Query, World};
-
-#[derive(Debug, Component)]
-struct Position
-{
-    x: u32,
-    y: u32,
-}
-
-#[derive(Debug, Component)]
-struct EnemySpawnSource;
-
-#[derive(Debug, Component)]
-enum EvilnessLevel
-{
-    Medium,
-}
-
-fn spawn_enemies(
-    spawner_query: Query<(&EnemySpawnSource, &Position)>,
-    enemies_query: Query<(&EvilnessLevel,)>,
-    mut actions: Actions,
-)
-{
-    let Some((_, enemy_spawner_position)) = spawner_query.iter().next() else {
-        return;
-    };
-
-    let enemy_cnt = enemies_query.iter().count();
-
-    if enemy_cnt > 3 {
-        return;
-    }
-
-    actions.spawn((
-        EvilnessLevel::Medium,
-        Position {
-            x: enemy_spawner_position.x * enemy_cnt as u32,
-            y: enemy_spawner_position.y,
-        },
-    ));
-
-    println!("Spawned enemy with medium evilness and 45 strength");
-}
-
-struct EnemySpawningExtension;
-
-impl Extension for EnemySpawningExtension
-{
-    fn collect(self, mut collector: ExtensionCollector<'_>)
-    {
-        collector.add_system(*UPDATE_PHASE, spawn_enemies);
-
-        collector.add_entity((Position { x: 187, y: 30 }, EnemySpawnSource));
-    }
-}
-
-fn main()
-{
-    let mut world = World::new();
-
-    world.add_extension(EnemySpawningExtension);
-
-    for _ in 0..7 {
-        world.step();
-    }
-}
diff --git a/ecs/examples/multiple_queries.rs b/ecs/examples/multiple_queries.rs
deleted file mode 100644
index e0c957f..0000000
--- a/ecs/examples/multiple_queries.rs
+++ /dev/null
@@ -1,85 +0,0 @@
-use std::fmt::Display;
-
-use ecs::phase::START as START_PHASE;
-use ecs::{Component, Query, World};
-
-#[derive(Component)]
-struct Health
-{
-    health: u32,
-}
-
-#[derive(Component)]
-enum AttackStrength
-{
-    Strong,
-    Weak,
-}
-
-#[derive(Component)]
-struct EnemyName
-{
-    name: String,
-}
-
-impl Display for EnemyName
-{
-    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
-    {
-        self.name.fmt(formatter)
-    }
-}
-
-fn do_attacks(
-    attacker_query: Query<(&AttackStrength,)>,
-    enemy_query: Query<(&mut Health, &EnemyName)>,
-)
-{
-    for (attack_strength,) in &attacker_query {
-        for (mut health, enemy_name) in &enemy_query {
-            let damage = match *attack_strength {
-                AttackStrength::Strong => 20,
-                AttackStrength::Weak => 10,
-            };
-
-            if health.health <= damage {
-                println!("Enemy '{}' died", *enemy_name);
-
-                health.health = 0;
-
-                continue;
-            }
-
-            health.health -= damage;
-
-            println!("Enemy '{}' took {damage} damage", *enemy_name);
-        }
-    }
-}
-
-fn main()
-{
-    let mut world = World::new();
-
-    world.register_system(*START_PHASE, do_attacks);
-
-    world.create_entity((
-        Health { health: 100 },
-        EnemyName { name: "Big spider".to_string() },
-    ));
-
-    world.create_entity((
-        Health { health: 30 },
-        EnemyName { name: "Small goblin".to_string() },
-    ));
-
-    world.create_entity((
-        Health { health: 30 },
-        EnemyName { name: "Headcrab".to_string() },
-    ));
-
-    world.create_entity((AttackStrength::Strong,));
-    world.create_entity((AttackStrength::Weak,));
-
-    world.step();
-}
diff --git a/ecs/examples/optional_component.rs b/ecs/examples/optional_component.rs
deleted file mode 100644
index ebc9115..0000000
--- a/ecs/examples/optional_component.rs
+++ /dev/null
@@ -1,81 +0,0 @@
-use ecs::phase::UPDATE as UPDATE_PHASE;
-use ecs::{Component, Query, World};
-
-#[derive(Debug, Component)]
-struct PettingCapacity
-{
-    capacity_left: u32,
-}
-
-#[derive(Debug, Clone, Copy, Component)]
-enum Aggressivity
-{
-    High,
-    Medium,
-    Low,
-}
-
-#[derive(Debug, Component)]
-pub struct CatName
-{
-    name: String,
-}
-
-fn pet_cats(query: Query<(&CatName, &mut PettingCapacity, Option<&Aggressivity>)>)
-{
-    for (cat_name, mut petting_capacity, aggressivity) in &query {
-        let Some(aggressivity) = aggressivity else {
-            println!("Aggressivity of cat {} is unknown. Skipping", cat_name.name);
-            continue;
-        };
-
-        if let Aggressivity::High = *aggressivity {
-            println!("Cat {} is aggressive. Skipping", cat_name.name);
-            continue;
-        }
-
-        if petting_capacity.capacity_left == 0 {
-            println!(
-                "Cat {} have had enough of being petted. Skipping",
-                cat_name.name
-            );
-            continue;
-        }
-
-        println!("Petting cat {}", cat_name.name);
-
-        petting_capacity.capacity_left -= 1;
-    }
-}
-
-fn main()
-{
-    let mut world = World::new();
-
-    world.register_system(*UPDATE_PHASE, pet_cats);
-
-    world.create_entity((
-        CatName { name: "Jasper".to_string() },
-        Aggressivity::Medium,
-        PettingCapacity { capacity_left: 5 },
-    ));
-
-    world.create_entity((
-        CatName { name: "Otto".to_string() },
-        PettingCapacity { capacity_left: 9 },
-    ));
-
-    world.create_entity((
-        CatName { name: "Carrie".to_string() },
-        PettingCapacity { capacity_left: 2 },
-        Aggressivity::High,
-    ));
-
-    world.create_entity((
-        CatName { name: "Tommy".to_string() },
-        PettingCapacity { capacity_left: 1 },
-        Aggressivity::Low,
-    ));
-
-    world.step();
-}
diff --git a/ecs/examples/relationship.rs b/ecs/examples/relationship.rs
deleted file mode 100644
index 4e94151..0000000
--- a/ecs/examples/relationship.rs
+++ /dev/null
@@ -1,56 +0,0 @@
-use ecs::pair::{Pair, Wildcard};
-use ecs::phase::START as START_PHASE;
-use ecs::{Component, Query, World};
-
-#[derive(Component)]
-struct Sword
-{
-    attack_strength: u32,
-}
-
-#[derive(Component)]
-struct Player;
-
-#[derive(Component)]
-struct Health
-{
-    health: u32,
-}
-
-#[derive(Component)]
-struct Holding;
-
-fn print_player_stats(player_query: Query<(&Player, &Health, Pair<Holding, Wildcard>)>)
-{
-    for (_, health, target_sword) in &player_query {
-        println!("Player health: {}", health.health);
-
-        if let Some(sword_ent) = target_sword.get_target_ent() {
-            let sword = sword_ent
-                .get::<Sword>()
-                .expect("Sword entity is missing sword component");
-
-            println!("Player sword attack strength: {}", sword.attack_strength);
-        }
-    }
-}
-
-fn main()
-{
-    let mut world = World::new();
-
-    world.register_system(*START_PHASE, print_player_stats);
-
-    let sword_uid = world.create_entity((Sword { attack_strength: 17 },));
-
-    world.create_entity((
-        Player,
-        Health { health: 180 },
-        Pair::builder()
-            .relation::<Holding>()
-            .target_id(sword_uid)
-            .build(),
-    ));
-
-    world.step();
-}
diff --git a/ecs/examples/simple.rs b/ecs/examples/simple.rs
deleted file mode 100644
index 0169062..0000000
--- a/ecs/examples/simple.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-use ecs::phase::START as START_PHASE;
-use ecs::{Component, Query, World};
-
-#[derive(Component)]
-struct SomeData
-{
-    num: u64,
-}
-
-#[derive(Component)]
-struct Greeting
-{
-    greeting: String,
-}
-
-fn say_hello(query: Query<(&SomeData, &Greeting)>)
-{
-    for (data, greeting) in &query {
-        println!("{}: {}", greeting.greeting, data.num);
-    }
-}
-
-fn main()
-{
-    let mut world = World::new();
-
-    world.register_system(*START_PHASE, say_hello);
-
-    world.create_entity((
-        SomeData { num: 987_654 },
-        Greeting {
-            greeting: "Good afternoon".to_string(),
-        },
-    ));
-
-    world.create_entity((
-        SomeData { num: 345 },
-        Greeting { greeting: "Good evening".to_string() },
-    ));
-
-    world.step();
-}
diff --git a/ecs/examples/with_local.rs b/ecs/examples/with_local.rs
deleted file mode 100644
index 7a36d0e..0000000
--- a/ecs/examples/with_local.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-use ecs::component::local::Local;
-use ecs::phase::UPDATE as UPDATE_PHASE;
-use ecs::system::initializable::Initializable;
-use ecs::system::Into;
-use ecs::{Component, Query, World};
-
-#[derive(Component)]
-struct SomeData
-{
-    num: u64,
-}
-
-#[derive(Component)]
-struct Name
-{
-    name: String,
-}
-
-#[derive(Component)]
-struct SayHelloState
-{
-    cnt: usize,
-}
-
-fn say_hello(query: Query<(&SomeData,)>, mut state: Local<SayHelloState>)
-{
-    for (data,) in &query {
-        println!("Hello there. Count {}: {}", state.cnt, data.num);
-
-        state.cnt += 1;
-    }
-}
-
-fn say_whats_up(query: Query<(&SomeData, &Name)>, mut state: Local<SayHelloState>)
-{
-    for (data, name) in &query {
-        println!(
-            "Whats up, {}. Number is {}. Count {}",
-            name.name, data.num, state.cnt
-        );
-
-        state.cnt += 1;
-    }
-}
-
-fn main()
-{
-    let mut world = World::new();
-
-    world.register_system(
-        *UPDATE_PHASE,
-        say_hello
-            .into_system()
-            .initialize((SayHelloState { cnt: 0 },)),
-    );
-
-    world.register_system(
-        *UPDATE_PHASE,
-        say_whats_up
-            .into_system()
-            .initialize((SayHelloState { cnt: 0 },)),
-    );
-
-    world.create_entity((SomeData { num: 987_654 }, Name { name: "Bob".to_string() }));
-
-    world.create_entity((SomeData { num: 345 },));
-
-    world.step();
-    world.step();
-}
diff --git a/ecs/examples/with_sole.rs b/ecs/examples/with_sole.rs
deleted file mode 100644
index 7e89b0a..0000000
--- a/ecs/examples/with_sole.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-use ecs::pair::{ChildOf, Pair};
-use ecs::phase::{Phase, UPDATE as UPDATE_PHASE};
-use ecs::sole::Single;
-use ecs::{declare_entity, Component, Query, Sole, World};
-
-#[derive(Component)]
-struct Ammo
-{
-    ammo_left: u32,
-}
-
-#[derive(Sole, Default)]
-struct AmmoCounter
-{
-    counter: u32,
-}
-
-fn count_ammo(query: Query<(&Ammo,)>, mut ammo_counter: Single<AmmoCounter>)
-{
-    for (ammo,) in &query {
-        println!("Found {} ammo", ammo.ammo_left);
-
-        ammo_counter.counter += ammo.ammo_left;
-    }
-}
-
-fn print_total_ammo_count(ammo_counter: Single<AmmoCounter>)
-{
-    println!("Total ammo count: {}", ammo_counter.counter);
-
-    assert_eq!(ammo_counter.counter, 19);
-}
-
-declare_entity!(
-    PRINT_AMMO_COUNT_PHASE,
-    (
-        Phase,
-        Pair::builder()
-            .relation::<ChildOf>()
-            .target_id(*UPDATE_PHASE)
-            .build()
-    )
-);
-
-fn main()
-{
-    let mut world = World::new();
-
-    world.create_declared_entity(&PRINT_AMMO_COUNT_PHASE);
-
-    world.register_system(*UPDATE_PHASE, count_ammo);
-    world.register_system(*PRINT_AMMO_COUNT_PHASE, print_total_ammo_count);
-
-    world.create_entity((Ammo { ammo_left: 4 },));
-    world.create_entity((Ammo { ammo_left: 7 },));
-    world.create_entity((Ammo { ammo_left: 8 },));
-
-    world.add_sole(AmmoCounter::default()).unwrap();
-
-    world.step();
-}
diff --git a/ecs/src/actions.rs b/ecs/src/actions.rs
deleted file mode 100644
index 3d8afe6..0000000
--- a/ecs/src/actions.rs
+++ /dev/null
@@ -1,174 +0,0 @@
-use crate::component::{Parts as ComponentParts, Sequence as ComponentSequence};
-use crate::event::component::Removed;
-use crate::pair::Pair;
-use crate::system::{Metadata as SystemMetadata, Param as SystemParam};
-use crate::uid::{Kind as UidKind, Uid, WithUidTuple};
-use crate::{ActionQueue, World};
-
-/// Used to to queue up actions for a [`World`] to perform.
-#[derive(Debug)]
-pub struct Actions<'world>
-{
-    action_queue: &'world ActionQueue,
-    world: Option<&'world World>,
-}
-
-impl Actions<'_>
-{
-    /// Queues up a entity to spawn at the end of the current tick, returning the [`Uid`]
-    /// that the entity will have.
-    pub fn spawn<Comps: ComponentSequence>(&mut self, components: Comps) -> Uid
-    {
-        let new_entity_uid = Uid::new_unique(UidKind::Entity);
-
-        self.action_queue.push(Action::Spawn(
-            new_entity_uid,
-            components.into_parts_array().into(),
-        ));
-
-        new_entity_uid
-    }
-
-    /// Queues up despawning a entity at the end of the current tick.
-    pub fn despawn(&mut self, entity_uid: Uid)
-    {
-        debug_assert_eq!(entity_uid.kind(), UidKind::Entity);
-
-        let Some(world) = self.world else {
-            self.action_queue.push(Action::Despawn(entity_uid));
-            return;
-        };
-
-        let Some(ent) = world.get_entity(entity_uid) else {
-            tracing::warn!("Cannot entity that doesn't exist");
-            return;
-        };
-
-        // TODO: Submit all events with a single function call to reduce overhead
-        for comp_id in ent.component_ids() {
-            if comp_id.kind() == UidKind::Pair {
-                continue;
-            }
-
-            world.event_submitter().submit_event(
-                &Pair::builder()
-                    .relation::<Removed>()
-                    .target_id(comp_id)
-                    .build(),
-                entity_uid,
-            );
-        }
-
-        self.action_queue.push(Action::Despawn(entity_uid));
-    }
-
-    /// Queues up adding component(s) to a entity at the end of the current tick.
-    pub fn add_components<Comps>(&mut self, entity_uid: Uid, components: Comps)
-    where
-        Comps: ComponentSequence,
-    {
-        debug_assert_eq!(entity_uid.kind(), UidKind::Entity);
-
-        if Comps::COUNT == 0 {
-            return;
-        }
-
-        self.action_queue.push(Action::AddComponents(
-            entity_uid,
-            components.into_parts_array().into(),
-        ));
-    }
-
-    /// Queues up removing component(s) from a entity at the end of the current tick.
-    #[tracing::instrument(skip(self, component_ids))]
-    pub fn remove_components(
-        &mut self,
-        entity_uid: Uid,
-        component_ids: impl IntoIterator<Item = Uid>,
-    )
-    {
-        debug_assert_eq!(entity_uid.kind(), UidKind::Entity);
-
-        let mut component_ids = component_ids.into_iter().peekable();
-
-        if component_ids.peek().is_none() {
-            return;
-        }
-
-        let Some(world) = self.world else {
-            self.action_queue.push(Action::RemoveComponents(
-                entity_uid,
-                component_ids.collect(),
-            ));
-            return;
-        };
-
-        let Some(ent) = world.get_entity(entity_uid) else {
-            tracing::warn!("Cannot remove components from entity that doesn't exist");
-            return;
-        };
-
-        let component_ids = component_ids
-            .filter(|comp_id| ent.has_component(*comp_id))
-            .collect::<Vec<_>>();
-
-        if component_ids.is_empty() {
-            return;
-        }
-
-        // TODO: Submit all events with a single function call to reduce overhead
-        for comp_id in &component_ids {
-            if comp_id.kind() == UidKind::Pair {
-                continue;
-            }
-
-            world.event_submitter().submit_event(
-                &Pair::builder()
-                    .relation::<Removed>()
-                    .target_id(*comp_id)
-                    .build(),
-                entity_uid,
-            );
-        }
-
-        self.action_queue
-            .push(Action::RemoveComponents(entity_uid, component_ids));
-    }
-
-    /// Queues up removing component(s) from a entity at the end of the current tick.
-    pub fn remove_comps<Ids: WithUidTuple>(&mut self, entity_uid: Uid)
-    {
-        self.remove_components(entity_uid, Ids::uids());
-    }
-
-    /// Stops the [`World`]. The world will finish the current tick and that tick will be
-    /// the last.
-    pub fn stop(&mut self)
-    {
-        self.action_queue.push(Action::Stop);
-    }
-}
-
-impl<'world> SystemParam<'world> for Actions<'world>
-{
-    type Input = ();
-
-    fn new(world: &'world World, _system_metadata: &SystemMetadata) -> Self
-    {
-        Self {
-            action_queue: &world.data.action_queue,
-            world: Some(world),
-        }
-    }
-}
-
-/// A action for a [`System`] to perform.
-#[derive(Debug)]
-pub(crate) enum Action
-{
-    Spawn(Uid, Vec<ComponentParts>),
-    Despawn(Uid),
-    AddComponents(Uid, Vec<ComponentParts>),
-    RemoveComponents(Uid, Vec<Uid>),
-    Stop,
-}
diff --git a/ecs/src/component.rs b/ecs/src/component.rs
deleted file mode 100644
index 17b279b..0000000
--- a/ecs/src/component.rs
+++ /dev/null
@@ -1,324 +0,0 @@
-use std::any::{type_name, Any};
-use std::fmt::Debug;
-use std::ops::{Deref, DerefMut};
-
-use seq_macro::seq;
-
-use crate::event::component::Changed;
-use crate::event::Submitter as EventSubmitter;
-use crate::lock::{
-    Error as LockError,
-    MappedReadGuard,
-    MappedWriteGuard,
-    ReadGuard,
-    WriteGuard,
-};
-use crate::pair::Pair;
-use crate::system::Input as SystemInput;
-use crate::uid::Uid;
-use crate::util::Array;
-use crate::{EntityComponentRef, World};
-
-pub mod local;
-
-pub(crate) mod storage;
-
-pub trait Component: SystemInput + Any
-{
-    /// Returns the ID of this component.
-    fn id() -> Uid
-    where
-        Self: Sized;
-
-    /// Returns the name of this component.
-    fn name(&self) -> &'static str;
-}
-
-impl dyn Component
-{
-    pub fn downcast_mut<Real: 'static>(&mut self) -> Option<&mut Real>
-    {
-        (self as &mut dyn Any).downcast_mut()
-    }
-
-    pub fn downcast_ref<Real: 'static>(&self) -> Option<&Real>
-    {
-        (self as &dyn Any).downcast_ref()
-    }
-
-    pub fn is<Other: 'static>(&self) -> bool
-    {
-        (self as &dyn Any).is::<Other>()
-    }
-}
-
-impl Debug for dyn Component
-{
-    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
-    {
-        formatter.debug_struct("Component").finish_non_exhaustive()
-    }
-}
-
-/// A sequence of components.
-pub trait Sequence
-{
-    /// The number of components in this component sequence.
-    const COUNT: usize;
-
-    type PartsArray: Array<Parts>;
-
-    fn into_parts_array(self) -> Self::PartsArray;
-}
-
-#[derive(Debug)]
-pub struct Handle<'a, DataT: 'static>
-{
-    inner: MappedReadGuard<'a, DataT>,
-}
-
-impl<'comp, DataT: 'static> Handle<'comp, DataT>
-{
-    /// Creates a new handle instance from a [`EntityComponentRef`].
-    ///
-    /// # Errors
-    /// Will return `Err` if acquiring the component's lock fails.
-    pub fn from_entity_component_ref(
-        entity_component_ref: &EntityComponentRef<'comp>,
-    ) -> Result<Self, HandleError>
-    {
-        Self::new(
-            entity_component_ref
-                .component()
-                .read_nonblock()
-                .map_err(AcquireLockError)?,
-        )
-    }
-
-    fn new(inner: ReadGuard<'comp, Box<dyn Any>>) -> Result<Self, HandleError>
-    {
-        Ok(Self {
-            inner: ReadGuard::try_map(inner, |component| {
-                component.downcast_ref::<DataT>()
-            })
-            .map_err(|_| HandleError::IncorrectType)?,
-        })
-    }
-}
-
-impl<DataT: 'static> Deref for Handle<'_, DataT>
-{
-    type Target = DataT;
-
-    fn deref(&self) -> &Self::Target
-    {
-        &self.inner
-    }
-}
-
-#[derive(Debug)]
-pub struct HandleMut<'a, DataT: 'static>
-{
-    entity_component_ref: EntityComponentRef<'a>,
-    inner: MappedWriteGuard<'a, DataT>,
-    event_submitter: EventSubmitter<'a>,
-}
-
-impl<'comp, DataT: 'static> HandleMut<'comp, DataT>
-{
-    /// Creates a new handle instance from a [`EntityComponentRef`].
-    ///
-    /// # Errors
-    /// Will return `Err` if acquiring the component's lock fails.
-    pub fn from_entity_component_ref(
-        entity_component_ref: &EntityComponentRef<'comp>,
-        world: &'comp World,
-    ) -> Result<Self, HandleError>
-    {
-        let inner = entity_component_ref
-            .component()
-            .write_nonblock()
-            .map_err(AcquireLockError)?;
-
-        Ok(Self {
-            entity_component_ref: entity_component_ref.clone(),
-            inner: WriteGuard::try_map(inner, |component| {
-                component.downcast_mut::<DataT>()
-            })
-            .map_err(|_| HandleError::IncorrectType)?,
-            event_submitter: world.event_submitter(),
-        })
-    }
-
-    pub fn set_changed(&self)
-    {
-        self.event_submitter.submit_event(
-            &Pair::builder()
-                .relation::<Changed>()
-                .target_id(self.entity_component_ref.id())
-                .build(),
-            self.entity_component_ref.entity_id(),
-        );
-    }
-}
-
-impl<DataT: 'static> Deref for HandleMut<'_, DataT>
-{
-    type Target = DataT;
-
-    fn deref(&self) -> &Self::Target
-    {
-        &self.inner
-    }
-}
-
-impl<DataT: 'static> DerefMut for HandleMut<'_, DataT>
-{
-    fn deref_mut(&mut self) -> &mut Self::Target
-    {
-        &mut self.inner
-    }
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum HandleError
-{
-    #[error(transparent)]
-    AcquireLockFailed(#[from] AcquireLockError),
-
-    #[error("Incorrect component type")]
-    IncorrectType,
-}
-
-#[derive(Debug, thiserror::Error)]
-#[error("Failed to acquire component lock")]
-pub struct AcquireLockError(#[source] LockError);
-
-macro_rules! inner {
-    ($c: tt) => {
-        seq!(I in 0..=$c {
-            impl<#(IntoCompParts~I: IntoParts,)*> Sequence for (#(IntoCompParts~I,)*)
-            {
-                const COUNT: usize = $c + 1;
-
-                type PartsArray = [Parts; $c + 1];
-
-                fn into_parts_array(self) -> Self::PartsArray
-                {
-                    [#({
-                        self.I.into_parts()
-                    },)*]
-                }
-            }
-        });
-    };
-}
-
-seq!(C in 0..=16 {
-    inner!(C);
-});
-
-impl Sequence for ()
-{
-    type PartsArray = [Parts; 0];
-
-    const COUNT: usize = 0;
-
-    fn into_parts_array(self) -> Self::PartsArray
-    {
-        []
-    }
-}
-
-pub trait IntoParts
-{
-    fn into_parts(self) -> Parts;
-}
-
-impl<ComponentT> IntoParts for ComponentT
-where
-    ComponentT: Component,
-{
-    fn into_parts(self) -> Parts
-    {
-        Parts::builder()
-            .name(type_name::<Self>())
-            .build(Self::id(), self)
-    }
-}
-
-/// The parts of a component.
-#[derive(Debug)]
-#[non_exhaustive]
-pub struct Parts
-{
-    id: Uid,
-    name: &'static str,
-    data: Box<dyn Any>,
-}
-
-impl Parts
-{
-    #[must_use]
-    pub fn id(&self) -> Uid
-    {
-        self.id
-    }
-
-    #[must_use]
-    pub fn name(&self) -> &'static str
-    {
-        self.name
-    }
-
-    #[must_use]
-    pub fn builder() -> PartsBuilder
-    {
-        PartsBuilder::default()
-    }
-
-    pub(crate) fn into_data(self) -> Box<dyn Any>
-    {
-        self.data
-    }
-}
-
-#[derive(Debug)]
-pub struct PartsBuilder
-{
-    name: &'static str,
-}
-
-impl PartsBuilder
-{
-    #[must_use]
-    pub fn name(mut self, name: &'static str) -> Self
-    {
-        self.name = name;
-        self
-    }
-
-    #[must_use]
-    pub fn build<Data: 'static>(self, id: Uid, data: Data) -> Parts
-    {
-        Parts {
-            id,
-            name: self.name,
-            data: Box::new(data),
-        }
-    }
-
-    #[must_use]
-    pub fn build_with_any_data(self, id: Uid, data: Box<dyn Any>) -> Parts
-    {
-        Parts { id, name: self.name, data }
-    }
-}
-
-impl Default for PartsBuilder
-{
-    fn default() -> Self
-    {
-        Self { name: "(unspecified)" }
-    }
-}
diff --git a/ecs/src/component/local.rs b/ecs/src/component/local.rs
deleted file mode 100644
index b19a30b..0000000
--- a/ecs/src/component/local.rs
+++ /dev/null
@@ -1,104 +0,0 @@
-use std::any::type_name;
-use std::ops::{Deref, DerefMut};
-
-use ecs_macros::Component;
-
-use crate::component::{
-    Component,
-    HandleMut as ComponentHandleMut,
-    IntoParts as _,
-    Parts as ComponentParts,
-};
-use crate::pair::Pair;
-use crate::system::initializable::Param as InitializableParam;
-use crate::system::{Metadata as SystemMetadata, Param as SystemParam};
-use crate::World;
-
-/// Holds a component which is local to a single system.
-#[derive(Debug)]
-pub struct Local<'world, LocalComponent: Component>
-{
-    local_component: ComponentHandleMut<'world, LocalComponent>,
-}
-
-impl<'world, LocalComponent> SystemParam<'world> for Local<'world, LocalComponent>
-where
-    LocalComponent: Component,
-{
-    type Input = LocalComponent;
-
-    fn new(world: &'world World, system_metadata: &SystemMetadata) -> Self
-    {
-        let Some(system_ent) = world.get_entity(system_metadata.ent_id) else {
-            panic!(
-                "System entity with ID {} does not exist",
-                system_metadata.ent_id
-            );
-        };
-
-        let Some(local_component) = system_ent.get_with_id_mut::<LocalComponent>(
-            Pair::builder()
-                .relation::<IsLocalComponent>()
-                .target::<LocalComponent>()
-                .build()
-                .id(),
-        ) else {
-            panic!(
-                "Local component {} of system with ID {} is uninitialized",
-                type_name::<LocalComponent>(),
-                system_metadata.ent_id
-            );
-        };
-
-        Self { local_component }
-    }
-}
-
-impl<'world, LocalComponent, SystemT> InitializableParam<'world, SystemT>
-    for Local<'world, LocalComponent>
-where
-    LocalComponent: Component,
-    SystemT: SystemWithLocalComponents,
-    Self: SystemParam<'world, Input = LocalComponent>,
-{
-    fn initialize(system: &mut SystemT, input: Self::Input)
-    {
-        system.add_local_component(
-            Pair::builder()
-                .relation::<IsLocalComponent>()
-                .target_as_data(input)
-                .build()
-                .into_parts(),
-        );
-    }
-}
-
-impl<LocalComponent> Deref for Local<'_, LocalComponent>
-where
-    LocalComponent: Component,
-{
-    type Target = LocalComponent;
-
-    fn deref(&self) -> &Self::Target
-    {
-        &self.local_component
-    }
-}
-
-impl<LocalComponent> DerefMut for Local<'_, LocalComponent>
-where
-    LocalComponent: Component,
-{
-    fn deref_mut(&mut self) -> &mut Self::Target
-    {
-        &mut self.local_component
-    }
-}
-
-pub trait SystemWithLocalComponents
-{
-    fn add_local_component(&mut self, component_parts: ComponentParts);
-}
-
-#[derive(Component)]
-struct IsLocalComponent;
diff --git a/ecs/src/component/storage.rs b/ecs/src/component/storage.rs
deleted file mode 100644
index dc38b6a..0000000
--- a/ecs/src/component/storage.rs
+++ /dev/null
@@ -1,795 +0,0 @@
-use std::any::Any;
-use std::array::IntoIter as ArrayIter;
-use std::cell::RefCell;
-use std::vec::IntoIter as VecIntoIter;
-
-use hashbrown::HashMap;
-
-use crate::component::storage::archetype::{
-    Archetype,
-    Entity as ArchetypeEntity,
-    EntityComponent as ArchetypeEntityComponent,
-    Id as ArchetypeId,
-};
-use crate::component::storage::graph::{
-    ArchetypeAddEdgeDfsIter,
-    ArchetypeAddEdgeDfsIterResult,
-    ArchetypeEdges,
-    Graph,
-};
-use crate::uid::{Kind as UidKind, Uid};
-use crate::util::{BorrowedOrOwned, Either, StreamingIterator, VecExt};
-
-pub mod archetype;
-
-mod graph;
-
-#[derive(Debug)]
-pub struct ArchetypeSearchTerms<'a>
-{
-    pub required_components: &'a [Uid],
-    pub excluded_components: &'a [Uid],
-}
-
-impl ArchetypeSearchTerms<'_>
-{
-    fn excluded_contains(&self, comp_id: Uid) -> bool
-    {
-        let comp_id_kind = comp_id.kind();
-
-        debug_assert!(
-            comp_id_kind == UidKind::Component
-                || (comp_id_kind == UidKind::Pair
-                    && comp_id.target_component() != Uid::wildcard())
-        );
-
-        let is_found = self.excluded_components.binary_search(&comp_id).is_ok();
-
-        if !is_found && comp_id_kind == UidKind::Pair {
-            return self.excluded_components.iter().any(|excluded_comp_id| {
-                excluded_comp_id.kind() == UidKind::Pair
-                    && excluded_comp_id.has_same_relation_as(comp_id)
-                    && excluded_comp_id.target_component() == Uid::wildcard()
-            });
-        }
-
-        is_found
-    }
-
-    fn contains_conflicting(&self) -> bool
-    {
-        self.excluded_components.iter().any(|excluded_comp_id| {
-            self.required_components
-                .binary_search(excluded_comp_id)
-                .is_ok()
-        })
-    }
-
-    fn archetype_contains_all_required(&self, archetype: &Archetype) -> bool
-    {
-        self.required_components
-            .iter()
-            .all(|comp_id| archetype.contains_matching_component(*comp_id))
-    }
-}
-
-#[derive(Debug, Default)]
-pub struct Storage
-{
-    graph: Graph,
-    entity_archetype_lookup: HashMap<Uid, ArchetypeId>,
-    imaginary_archetypes: RefCell<Vec<ImaginaryArchetype>>,
-}
-
-impl Storage
-{
-    pub fn search_archetypes<'search_terms>(
-        &self,
-        search_terms: ArchetypeSearchTerms<'search_terms>,
-    ) -> ArchetypeRefIter<'_, 'search_terms>
-    {
-        let archetype_id = ArchetypeId::new(search_terms.required_components);
-
-        if search_terms.contains_conflicting() {
-            return ArchetypeRefIter {
-                storage: self,
-                pre_iter: Either::B(Vec::new().into_iter()),
-                dfs_iter: ArchetypeAddEdgeDfsIter::new(&self.graph, &[]),
-                search_terms,
-            };
-        }
-
-        let Some(add_edge_recursive_iter) =
-            self.graph.dfs_archetype_add_edges(archetype_id)
-        else {
-            self.imaginary_archetypes
-                .borrow_mut()
-                .push(ImaginaryArchetype {
-                    id: ArchetypeId::new(search_terms.required_components.iter().filter(
-                        |required_comp_id| {
-                            required_comp_id.kind() != UidKind::Pair
-                                || required_comp_id.target_component() != Uid::wildcard()
-                        },
-                    )),
-                    component_ids: search_terms
-                        .required_components
-                        .iter()
-                        .copied()
-                        .filter(|required_comp_id| {
-                            required_comp_id.kind() != UidKind::Pair
-                                || required_comp_id.target_component() != Uid::wildcard()
-                        })
-                        .collect(),
-                });
-
-            let found_archetypes = self.find_all_archetype_with_comps(&search_terms);
-
-            return ArchetypeRefIter {
-                storage: self,
-                pre_iter: Either::B(found_archetypes.clone().into_iter()),
-                dfs_iter: ArchetypeAddEdgeDfsIter::new(&self.graph, &found_archetypes),
-                search_terms,
-            };
-        };
-
-        ArchetypeRefIter {
-            storage: self,
-            pre_iter: Either::A([archetype_id].into_iter()),
-            dfs_iter: add_edge_recursive_iter,
-            search_terms,
-        }
-    }
-
-    pub fn get_archetype_by_id(&self, id: ArchetypeId) -> Option<&Archetype>
-    {
-        Some(self.graph.get_node_by_id(id)?.archetype())
-    }
-
-    pub fn create_entity(&mut self, uid: Uid) -> Result<(), EntityAlreadyExistsError>
-    {
-        debug_assert_eq!(uid.kind(), UidKind::Entity);
-
-        if self.entity_archetype_lookup.contains_key(&uid) {
-            return Err(EntityAlreadyExistsError);
-        }
-
-        let empty_archetype_id = ArchetypeId::new_empty();
-
-        let archetype_node = self.graph.get_or_create_node(empty_archetype_id, &[]);
-
-        archetype_node
-            .archetype_mut()
-            .push_entity(ArchetypeEntity::new(uid, []));
-
-        self.entity_archetype_lookup.insert(uid, empty_archetype_id);
-
-        Ok(())
-    }
-
-    pub fn remove_entity(&mut self, entity_uid: Uid) -> Result<ArchetypeEntity, Error>
-    {
-        let Some(archetype_id) = self.entity_archetype_lookup.get(&entity_uid) else {
-            return Err(Error::EntityDoesNotExist(entity_uid));
-        };
-
-        let archetype_node = self
-            .graph
-            .get_node_by_id_mut(*archetype_id)
-            .expect("Archetype should exist");
-
-        let entity = archetype_node
-            .archetype_mut()
-            .remove_entity(entity_uid)
-            .expect("Entity should exist in archetype");
-
-        self.entity_archetype_lookup.remove(&entity_uid);
-
-        Ok(entity)
-    }
-
-    pub fn get_entity_archetype(&self, entity_uid: Uid) -> Option<&Archetype>
-    {
-        let archetype_id = self.entity_archetype_lookup.get(&entity_uid)?;
-
-        self.get_archetype_by_id(*archetype_id)
-    }
-
-    pub fn add_entity_component(
-        &mut self,
-        entity_uid: Uid,
-        (component_id, component_name, component): (Uid, &'static str, Box<dyn Any>),
-    ) -> Result<(), Error>
-    {
-        let Some(archetype_id) = self.entity_archetype_lookup.get(&entity_uid) else {
-            return Err(Error::EntityDoesNotExist(entity_uid));
-        };
-
-        let archetype_id = *archetype_id;
-
-        let archetype_node = self
-            .graph
-            .get_node_by_id_mut(archetype_id)
-            .expect("Archetype should exist");
-
-        if archetype_node
-            .archetype()
-            .contains_component_with_exact_id(component_id)
-        {
-            return Err(Error::ComponentAlreadyInEntity {
-                entity: entity_uid,
-                component: component_id,
-            });
-        }
-
-        let add_edge_archetype_id = if let Some(add_edge_id) = archetype_node
-            .get_or_insert_edges(component_id, ArchetypeEdges::default)
-            .add
-        {
-            if !self.graph.contains_archetype(add_edge_id) {
-                let (_, add_edge_comp_ids) = self
-                    .graph
-                    .get_node_by_id(archetype_id)
-                    .expect("Archetype should exist")
-                    .make_add_edge(component_id);
-
-                self.graph.create_node(add_edge_id, &add_edge_comp_ids);
-            }
-
-            add_edge_id
-        } else {
-            let archetype_node = self
-                .graph
-                .get_node_by_id(archetype_id)
-                .expect("Archetype should exist");
-
-            let (add_edge_id, add_edge_comp_ids) =
-                archetype_node.make_add_edge(component_id);
-
-            if !self.graph.contains_archetype(add_edge_id) {
-                self.graph.create_node(add_edge_id, &add_edge_comp_ids);
-            }
-
-            add_edge_id
-        };
-
-        let archetype_node = self
-            .graph
-            .get_node_by_id_mut(archetype_id)
-            .expect("Archetype should exist");
-
-        let mut entity = archetype_node
-            .archetype_mut()
-            .remove_entity(entity_uid)
-            .expect("Entity should exist in archetype");
-
-        let add_edge_archetype = self
-            .graph
-            .get_node_by_id_mut(add_edge_archetype_id)
-            .expect("Add edge archetype should exist")
-            .archetype_mut();
-
-        entity.insert_component(
-            component_id,
-            ArchetypeEntityComponent::new(component, component_name),
-            add_edge_archetype,
-        );
-
-        add_edge_archetype.push_entity(entity);
-
-        self.entity_archetype_lookup
-            .insert(entity_uid, add_edge_archetype_id);
-
-        Ok(())
-    }
-
-    pub fn remove_entity_component(
-        &mut self,
-        entity_uid: Uid,
-        component_id: Uid,
-    ) -> Result<(), Error>
-    {
-        let Some(archetype_id) = self.entity_archetype_lookup.get(&entity_uid) else {
-            return Err(Error::EntityDoesNotExist(entity_uid));
-        };
-
-        let archetype_id = *archetype_id;
-
-        let archetype_node = self
-            .graph
-            .get_node_by_id_mut(archetype_id)
-            .expect("Archetype should exist");
-
-        if !archetype_node
-            .archetype()
-            .contains_component_with_exact_id(component_id)
-        {
-            return Err(Error::ComponentNotFoundInEntity {
-                entity: entity_uid,
-                component: component_id,
-            });
-        }
-
-        let remove_edge_id = archetype_node
-            .get_or_insert_edges(component_id, ArchetypeEdges::default)
-            .remove
-            .unwrap_or_else(|| {
-                let archetype_node = self
-                    .graph
-                    .get_node_by_id_mut(archetype_id)
-                    .expect("Archetype should exist");
-
-                let (remove_edge_id, remove_edge_comp_ids) =
-                    archetype_node.make_remove_edge(component_id);
-
-                if !self.graph.contains_archetype(remove_edge_id) {
-                    self.graph
-                        .create_node(remove_edge_id, &remove_edge_comp_ids);
-                }
-
-                remove_edge_id
-            });
-
-        let archetype_node = self
-            .graph
-            .get_node_by_id_mut(archetype_id)
-            .expect("Archetype should exist");
-
-        let mut entity = archetype_node
-            .archetype_mut()
-            .remove_entity(entity_uid)
-            .expect("Entity should exist in archetype");
-
-        let removed_component =
-            entity.remove_component(component_id, archetype_node.archetype());
-
-        self.graph
-            .get_node_by_id_mut(remove_edge_id)
-            .expect("Remove edge archetype should exist")
-            .archetype_mut()
-            .push_entity(entity);
-
-        self.entity_archetype_lookup
-            .insert(entity_uid, remove_edge_id);
-
-        tracing::debug!(
-            entity_id = %entity_uid,
-            component_id = %component_id,
-            component_name = removed_component.name(),
-            "Removed component from entity"
-        );
-
-        Ok(())
-    }
-
-    pub fn create_imaginary_archetypes(&mut self)
-    {
-        for imaginary_archetype in self.imaginary_archetypes.get_mut().drain(..) {
-            if self.graph.contains_archetype(imaginary_archetype.id) {
-                continue;
-            }
-
-            self.graph
-                .create_node(imaginary_archetype.id, &imaginary_archetype.component_ids);
-        }
-    }
-
-    fn find_all_archetype_with_comps(
-        &self,
-        search_terms: &ArchetypeSearchTerms<'_>,
-    ) -> Vec<ArchetypeId>
-    {
-        let Some(mut search_iter) =
-            self.graph.dfs_archetype_add_edges(ArchetypeId::new_empty())
-        else {
-            // If the root archetype doesn't exist, no other archetype can exist either
-            //
-            // TODO: The above comment is not true. Cases where imaginary archetypes have
-            // been created should be handled as well
-            return Vec::new();
-        };
-
-        let mut found = Vec::<ArchetypeId>::new();
-
-        while let Some(node_id) = search_iter.streaming_next() {
-            let ArchetypeAddEdgeDfsIterResult::AddEdge {
-                add_edge_archetype_id: node_id,
-                add_edge_component_id,
-            } = node_id
-            else {
-                continue;
-            };
-
-            if search_terms.excluded_contains(add_edge_component_id) {
-                search_iter.pop();
-                continue;
-            }
-
-            let node = self
-                .graph
-                .get_node_by_id(node_id)
-                .expect("Graph node found through DFS doesn't exist");
-
-            if node.archetype().component_cnt() < search_terms.required_components.len() {
-                continue;
-            }
-
-            if !search_terms.archetype_contains_all_required(node.archetype()) {
-                continue;
-            }
-
-            found.push(node.archetype().id());
-
-            search_iter.pop();
-        }
-
-        found
-    }
-}
-
-#[cfg(feature = "vizoxide")]
-impl Storage
-{
-    pub fn create_vizoxide_archetype_graph(
-        &self,
-        graph_name: impl AsRef<str>,
-        params: VizoxideArchetypeGraphParams,
-    ) -> Result<vizoxide::Graph, vizoxide::GraphvizError>
-    {
-        let viz_graph = vizoxide::Graph::builder(graph_name.as_ref())
-            .strict(true)
-            .directed(true)
-            .build()?;
-
-        let mut viz_node_lookup = HashMap::new();
-
-        for node in self.graph.iter_nodes() {
-            let id = node.archetype().id();
-
-            if !viz_node_lookup.contains_key(&id) {
-                let node = self.graph.get_node_by_id(id).unwrap();
-
-                let viz_node = (params.create_node_cb)(
-                    node.archetype(),
-                    ArchetypeMetadata { is_imaginary: false },
-                    viz_graph.create_node(&(params.create_node_name)(
-                        node.archetype(),
-                        ArchetypeMetadata { is_imaginary: false },
-                    )),
-                )
-                .build()?;
-
-                viz_node_lookup.insert(id, viz_node);
-            }
-
-            for (edge_comp_id, edges) in node.iter_edges() {
-                if let Some(add_edge) = edges.add {
-                    if !viz_node_lookup.contains_key(&add_edge) {
-                        let viz_node = self.create_vizoxide_archetype_graph_edge_node(
-                            &viz_graph,
-                            node,
-                            add_edge,
-                            *edge_comp_id,
-                            &params,
-                        )?;
-
-                        viz_node_lookup.insert(add_edge, viz_node);
-                    }
-
-                    (params.create_edge_cb)(
-                        node.archetype(),
-                        *edge_comp_id,
-                        VizoxideArchetypeGraphEdgeKind::Add,
-                        viz_graph.create_edge(
-                            viz_node_lookup.get(&id).unwrap(),
-                            viz_node_lookup.get(&add_edge).unwrap(),
-                            Some(&format!("Add {}", edge_comp_id.id())),
-                        ),
-                    )
-                    .build()?;
-                }
-
-                if let Some(remove_edge) = edges.remove {
-                    if !viz_node_lookup.contains_key(&remove_edge) {
-                        let viz_node = self.create_vizoxide_archetype_graph_edge_node(
-                            &viz_graph,
-                            node,
-                            remove_edge,
-                            *edge_comp_id,
-                            &params,
-                        )?;
-
-                        viz_node_lookup.insert(remove_edge, viz_node);
-                    }
-
-                    (params.create_edge_cb)(
-                        node.archetype(),
-                        *edge_comp_id,
-                        VizoxideArchetypeGraphEdgeKind::Remove,
-                        viz_graph.create_edge(
-                            viz_node_lookup.get(&id).unwrap(),
-                            viz_node_lookup.get(&remove_edge).unwrap(),
-                            Some(&format!("Remove {}", edge_comp_id.id())),
-                        ),
-                    )
-                    .build()?;
-                }
-            }
-        }
-
-        drop(viz_node_lookup);
-
-        Ok(viz_graph)
-    }
-
-    fn create_vizoxide_archetype_graph_edge_node<'vizoxide_graph>(
-        &self,
-        viz_graph: &'vizoxide_graph vizoxide::Graph,
-        node: &graph::ArchetypeNode,
-        edge_id: ArchetypeId,
-        edge_comp_id: Uid,
-        params: &VizoxideArchetypeGraphParams,
-    ) -> Result<vizoxide::Node<'vizoxide_graph>, vizoxide::GraphvizError>
-    {
-        match self.graph.get_node_by_id(edge_id) {
-            Some(edge_node) => (params.create_node_cb)(
-                edge_node.archetype(),
-                ArchetypeMetadata { is_imaginary: false },
-                viz_graph.create_node(&(params.create_node_name)(
-                    edge_node.archetype(),
-                    ArchetypeMetadata { is_imaginary: false },
-                )),
-            )
-            .build(),
-            None => {
-                let mut comp_ids =
-                    node.archetype().component_ids_sorted().collect::<Vec<_>>();
-
-                let insert_index = comp_ids.partition_point(|cid| *cid <= edge_comp_id);
-
-                comp_ids.insert(insert_index, edge_comp_id);
-
-                let imaginary_edge_archetype = Archetype::new(edge_id, comp_ids);
-
-                (params.create_node_cb)(
-                    &imaginary_edge_archetype,
-                    ArchetypeMetadata { is_imaginary: true },
-                    viz_graph.create_node(&(params.create_node_name)(
-                        &imaginary_edge_archetype,
-                        ArchetypeMetadata { is_imaginary: true },
-                    )),
-                )
-                .build()
-            }
-        }
-    }
-}
-
-#[cfg(feature = "vizoxide")]
-pub struct VizoxideArchetypeGraphParams
-{
-    pub create_node_name: fn(&Archetype, ArchetypeMetadata) -> std::borrow::Cow<'_, str>,
-    pub create_node_cb: for<'storage, 'graph> fn(
-        &'storage Archetype,
-        ArchetypeMetadata,
-        vizoxide::NodeBuilder<'graph>,
-    ) -> vizoxide::NodeBuilder<'graph>,
-    pub create_edge_cb: for<'storage, 'graph> fn(
-        &'storage Archetype,
-        Uid,
-        VizoxideArchetypeGraphEdgeKind,
-        vizoxide::EdgeBuilder<'graph>,
-    ) -> vizoxide::EdgeBuilder<'graph>,
-}
-
-#[cfg(feature = "vizoxide")]
-#[derive(Debug, Clone)]
-pub struct ArchetypeMetadata
-{
-    pub is_imaginary: bool,
-}
-
-#[cfg(feature = "vizoxide")]
-#[derive(Debug, Clone, Copy)]
-pub enum VizoxideArchetypeGraphEdgeKind
-{
-    Add,
-    Remove,
-}
-
-#[derive(Debug)]
-pub struct ArchetypeRefIter<'storage, 'search_terms>
-{
-    storage: &'storage Storage,
-    pre_iter: Either<ArrayIter<ArchetypeId, 1>, VecIntoIter<ArchetypeId>>,
-    dfs_iter: ArchetypeAddEdgeDfsIter<'storage>,
-    search_terms: ArchetypeSearchTerms<'search_terms>,
-}
-
-impl<'component_storage> Iterator for ArchetypeRefIter<'component_storage, '_>
-{
-    type Item = &'component_storage Archetype;
-
-    fn next(&mut self) -> Option<Self::Item>
-    {
-        if let Some(pre_iter_archetype_id) = self.pre_iter.next() {
-            return Some(
-                self.storage
-                    .get_archetype_by_id(pre_iter_archetype_id)
-                    .expect("Archetype should exist"),
-            );
-        }
-
-        let archetype_id = loop {
-            match self.dfs_iter.streaming_find(|res| {
-                matches!(
-                    res,
-                    ArchetypeAddEdgeDfsIterResult::AddEdge { .. }
-                        | ArchetypeAddEdgeDfsIterResult::AddEdgeArchetypeNotFound { .. }
-                )
-            })? {
-                ArchetypeAddEdgeDfsIterResult::AddEdge {
-                    add_edge_archetype_id,
-                    add_edge_component_id,
-                } => {
-                    if self.search_terms.excluded_contains(add_edge_component_id) {
-                        self.dfs_iter.pop();
-                        continue;
-                    }
-
-                    break add_edge_archetype_id;
-                }
-                ArchetypeAddEdgeDfsIterResult::AddEdgeArchetypeNotFound {
-                    archetype,
-                    add_edge_archetype_id,
-                    add_edge_component_id,
-                } => {
-                    if self.search_terms.excluded_contains(add_edge_component_id) {
-                        continue;
-                    }
-
-                    let mut add_edge_archetype_comps =
-                        archetype.component_ids_sorted().collect::<Vec<_>>();
-
-                    add_edge_archetype_comps
-                        .insert_at_part_pt_by_key(add_edge_component_id, |comp_id| {
-                            comp_id
-                        });
-
-                    self.storage.imaginary_archetypes.borrow_mut().push(
-                        ImaginaryArchetype {
-                            id: add_edge_archetype_id,
-                            component_ids: add_edge_archetype_comps.clone(),
-                        },
-                    );
-
-                    let found =
-                        self.find_edges_of_imaginary_archetype(&add_edge_archetype_comps);
-
-                    self.dfs_iter.push((
-                        BorrowedOrOwned::Owned(Archetype::new(
-                            add_edge_archetype_id,
-                            add_edge_archetype_comps.clone(),
-                        )),
-                        found.into_iter(),
-                    ));
-                }
-                _ => {
-                    unreachable!();
-                }
-            }
-        };
-
-        Some(
-            self.storage
-                .get_archetype_by_id(archetype_id)
-                .expect("Archetype should exist"),
-        )
-    }
-}
-
-impl ArchetypeRefIter<'_, '_>
-{
-    fn find_edges_of_imaginary_archetype(
-        &self,
-        imaginary_archetype_comps: &[Uid],
-    ) -> Vec<(Uid, ArchetypeEdges)>
-    {
-        self.storage
-            .find_all_archetype_with_comps(&ArchetypeSearchTerms {
-                required_components: imaginary_archetype_comps,
-                excluded_components: &[],
-            })
-            .into_iter()
-            .filter_map(|found_id| {
-                let found_archetype = self.storage.get_archetype_by_id(found_id).unwrap();
-
-                if found_archetype.component_cnt() < imaginary_archetype_comps.len() + 1 {
-                    return None;
-                }
-
-                let unique_comp_id = found_archetype
-                    .component_ids_sorted()
-                    .find(|found_archetype_comp_id| {
-                        !imaginary_archetype_comps.iter().any(
-                            |imaginary_archetype_comp_id| {
-                                *imaginary_archetype_comp_id == *found_archetype_comp_id
-                            },
-                        )
-                    })
-                    .expect("Oh noooo");
-
-                let mut add_edge_comp_ids = imaginary_archetype_comps.to_vec();
-
-                add_edge_comp_ids.insert_at_part_pt_by_key(unique_comp_id, |id| id);
-
-                let add_edge = ArchetypeId::new(&add_edge_comp_ids);
-
-                Some((
-                    unique_comp_id,
-                    ArchetypeEdges { add: Some(add_edge), remove: None },
-                ))
-            })
-            .collect::<Vec<_>>()
-    }
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum Error
-{
-    #[error("Entity with ID {0:?} does not exist")]
-    EntityDoesNotExist(Uid),
-
-    #[error("Entity with ID {entity:?} already has component with ID {component:?}")]
-    ComponentAlreadyInEntity
-    {
-        entity: Uid, component: Uid
-    },
-
-    #[error("Entity with ID {entity:?} does not have component with ID {component:?}")]
-    ComponentNotFoundInEntity
-    {
-        entity: Uid, component: Uid
-    },
-}
-
-#[derive(Debug, thiserror::Error)]
-#[error("Entity with already exists")]
-pub struct EntityAlreadyExistsError;
-
-#[derive(Debug)]
-struct ImaginaryArchetype
-{
-    id: ArchetypeId,
-    component_ids: Vec<Uid>,
-}
-
-#[cfg(test)]
-mod tests
-{
-    use crate::component::storage::Storage;
-    use crate::component::storage::archetype::Id as ArchetypeId;
-    use crate::uid::{Kind as UidKind, Uid};
-
-    #[test]
-    fn create_entity_works()
-    {
-        let mut new_storage = Storage::default();
-
-        let uid = Uid::new_unique(UidKind::Entity);
-
-        new_storage.create_entity(uid).expect("Expected Ok");
-
-        let archetype_node = new_storage
-            .graph
-            .get_node_by_id(ArchetypeId::new_empty())
-            .expect("Archetype for entities with no component doesn't exist");
-
-        assert_eq!(archetype_node.archetype().component_cnt(), 0);
-        assert_eq!(archetype_node.archetype().entity_cnt(), 1);
-
-        assert_eq!(
-            new_storage.entity_archetype_lookup.get(&uid).copied(),
-            Some(ArchetypeId::new_empty())
-        );
-    }
-}
diff --git a/ecs/src/component/storage/archetype.rs b/ecs/src/component/storage/archetype.rs
deleted file mode 100644
index a7fe7ed..0000000
--- a/ecs/src/component/storage/archetype.rs
+++ /dev/null
@@ -1,385 +0,0 @@
-use std::any::Any;
-use std::array::IntoIter as ArrayIntoIter;
-use std::hash::{DefaultHasher, Hash, Hasher};
-use std::iter::{Enumerate, Filter, Map, RepeatN, Zip};
-use std::option::IntoIter as OptionIntoIter;
-use std::slice::Iter as SliceIter;
-
-use hashbrown::HashMap;
-
-use crate::lock::Lock;
-use crate::uid::{Kind as UidKind, Uid};
-use crate::util::{Either, HashMapExt};
-
-#[derive(Debug)]
-pub struct Archetype
-{
-    id: Id,
-    entities: Vec<Entity>,
-    entity_index_lookup: HashMap<Uid, usize>,
-    component_index_lookup: HashMap<Uid, usize>,
-    component_ids: Vec<Uid>,
-}
-
-impl Archetype
-{
-    pub fn new(id: Id, component_ids: impl AsRef<[Uid]>) -> Self
-    {
-        Self {
-            id,
-            entities: Vec::new(),
-            entity_index_lookup: HashMap::new(),
-            component_index_lookup: component_ids
-                .as_ref()
-                .iter()
-                .enumerate()
-                .map(|(index, id)| (*id, index))
-                .collect(),
-            component_ids: component_ids.as_ref().to_vec(),
-        }
-    }
-
-    pub fn id(&self) -> Id
-    {
-        self.id
-    }
-
-    pub fn is_superset(&self, other: &Self) -> bool
-    {
-        self.component_index_lookup
-            .keys_is_superset(&other.component_index_lookup)
-    }
-
-    pub fn is_subset(&self, other: &Self) -> bool
-    {
-        self.component_index_lookup
-            .keys_is_subset(&other.component_index_lookup)
-    }
-
-    pub fn get_entity_by_id(&self, entity_uid: Uid) -> Option<&Entity>
-    {
-        let index = *self.entity_index_lookup.get(&entity_uid)?;
-
-        Some(self.entities.get(index).unwrap_or_else(|| {
-            panic!(
-                "In invalid state! Index of entity with ID {entity_uid:?} is out of bounds"
-            );
-        }))
-    }
-
-    pub fn push_entity(&mut self, entity: Entity)
-    {
-        self.entity_index_lookup
-            .insert(entity.uid, self.entities.len());
-
-        self.entities.push(entity);
-    }
-
-    pub fn remove_entity(&mut self, entity_uid: Uid) -> Option<Entity>
-    {
-        //debug_assert_eq!(entity_uid.kind(), UidKind::Entity);
-
-        let entity_index = self.entity_index_lookup.remove(&entity_uid)?;
-
-        if self.entities.len() == 1 {
-            return Some(self.entities.remove(entity_index));
-        }
-
-        let last_entity_uid = self
-            .entities
-            .last()
-            .expect(concat!(
-                "Invalid state. No entities in archetype but entry was ",
-                "removed successfully from entity index lookup"
-            ))
-            .uid;
-
-        // By using swap_remove, no memory reallocation occurs and only one index in the
-        // entity lookup needs to be updated
-        let removed_entity = self.entities.swap_remove(entity_index);
-
-        self.entity_index_lookup
-            .insert(last_entity_uid, entity_index);
-
-        Some(removed_entity)
-    }
-
-    pub fn entities(&self) -> EntityIter<'_>
-    {
-        EntityIter { iter: self.entities.iter() }
-    }
-
-    pub fn entity_cnt(&self) -> usize
-    {
-        self.entities.len()
-    }
-
-    pub fn component_cnt(&self) -> usize
-    {
-        self.component_index_lookup.len()
-    }
-
-    pub fn get_matching_component_indices(
-        &self,
-        component_id: Uid,
-    ) -> MatchingComponentIter<'_>
-    {
-        assert!(
-            component_id.kind() == UidKind::Component
-                || component_id.kind() == UidKind::Pair
-        );
-
-        if component_id.kind() == UidKind::Pair
-            && component_id.target_component() == Uid::wildcard()
-        {
-            return MatchingComponentIter {
-                inner: Either::A(
-                    self.component_ids
-                        .iter()
-                        .enumerate()
-                        .zip(std::iter::repeat_n(component_id, self.component_ids.len()))
-                        .filter(
-                            (|((_, other_comp_id), component_id)| {
-                                other_comp_id.kind() == UidKind::Pair
-                                    && other_comp_id.has_same_relation_as(*component_id)
-                            })
-                                as MatchingComponentIterFilterFn,
-                        )
-                        .map(|((index, other_comp_id), _)| (*other_comp_id, index)),
-                ),
-            };
-        }
-
-        MatchingComponentIter {
-            inner: Either::B(
-                [component_id]
-                    .into_iter()
-                    .zip(self.get_index_for_component(component_id)),
-            ),
-        }
-    }
-
-    pub fn get_index_for_component(&self, component_id: Uid) -> Option<usize>
-    {
-        assert!(
-            component_id.kind() == UidKind::Component
-                || (component_id.kind() == UidKind::Pair
-                    && component_id.target_component() != Uid::wildcard())
-        );
-
-        self.component_index_lookup.get(&component_id).copied()
-    }
-
-    pub fn component_ids_unsorted(&self) -> impl Iterator<Item = Uid> + '_
-    {
-        self.component_index_lookup.keys().copied()
-    }
-
-    pub fn component_ids_sorted(&self) -> impl Iterator<Item = Uid> + '_
-    {
-        self.component_ids.iter().copied()
-    }
-
-    pub fn contains_matching_component(&self, component_id: Uid) -> bool
-    {
-        let component_id_kind = component_id.kind();
-
-        debug_assert!(
-            component_id_kind == UidKind::Component || component_id_kind == UidKind::Pair
-        );
-
-        if component_id.kind() == UidKind::Pair
-            && component_id.target_component() == Uid::wildcard()
-        {
-            return self.component_ids.iter().any(|other_comp_id| {
-                other_comp_id.kind() == UidKind::Pair
-                    && other_comp_id.has_same_relation_as(component_id)
-            });
-        }
-
-        self.contains_component_with_exact_id(component_id)
-    }
-
-    pub fn contains_component_with_exact_id(&self, component_id: Uid) -> bool
-    {
-        let component_id_kind = component_id.kind();
-
-        debug_assert!(
-            component_id_kind == UidKind::Component
-                || (component_id_kind == UidKind::Pair
-                    && component_id.target_component() != Uid::wildcard())
-        );
-
-        self.component_index_lookup.contains_key(&component_id)
-    }
-}
-
-type MatchingComponentIterFilterFn = fn(&((usize, &Uid), Uid)) -> bool;
-
-type MatchingComponentIterMapFn = fn(((usize, &Uid), Uid)) -> (Uid, usize);
-
-type InnerMatchingComponentIterA<'archetype> = Map<
-    Filter<
-        Zip<Enumerate<SliceIter<'archetype, Uid>>, RepeatN<Uid>>,
-        MatchingComponentIterFilterFn,
-    >,
-    MatchingComponentIterMapFn,
->;
-
-type InnerMatchingComponentIterB = Zip<ArrayIntoIter<Uid, 1>, OptionIntoIter<usize>>;
-
-#[derive(Debug)]
-pub struct MatchingComponentIter<'archetype>
-{
-    inner: Either<InnerMatchingComponentIterA<'archetype>, InnerMatchingComponentIterB>,
-}
-
-impl Iterator for MatchingComponentIter<'_>
-{
-    type Item = (Uid, usize);
-
-    fn next(&mut self) -> Option<Self::Item>
-    {
-        self.inner.next()
-    }
-}
-
-#[derive(Debug)]
-pub struct EntityIter<'archetype>
-{
-    iter: SliceIter<'archetype, Entity>,
-}
-
-impl<'archetype> Iterator for EntityIter<'archetype>
-{
-    type Item = &'archetype Entity;
-
-    fn next(&mut self) -> Option<Self::Item>
-    {
-        self.iter.next()
-    }
-}
-
-#[derive(Debug)]
-pub struct Entity
-{
-    uid: Uid,
-    components: Vec<EntityComponent>,
-}
-
-impl Entity
-{
-    pub fn new(uid: Uid, components: impl IntoIterator<Item = EntityComponent>) -> Self
-    {
-        Self {
-            uid,
-            components: components.into_iter().collect(),
-        }
-    }
-
-    pub fn uid(&self) -> Uid
-    {
-        self.uid
-    }
-
-    pub fn components(&self) -> &[EntityComponent]
-    {
-        &self.components
-    }
-
-    pub fn remove_component(
-        &mut self,
-        component_id: Uid,
-        archetype: &Archetype,
-    ) -> EntityComponent
-    {
-        let index = archetype
-            .get_index_for_component(component_id)
-            .expect("Archetype should contain component");
-
-        self.components.remove(index)
-    }
-
-    pub fn insert_component(
-        &mut self,
-        component_id: Uid,
-        component: EntityComponent,
-        archetype: &Archetype,
-    )
-    {
-        let index = archetype
-            .get_index_for_component(component_id)
-            .expect("Archetype should contain component");
-
-        self.components.insert(index, component);
-    }
-}
-
-#[derive(Debug)]
-pub struct EntityComponent
-{
-    component: Lock<Box<dyn Any>>,
-    name: &'static str,
-}
-
-impl EntityComponent
-{
-    pub fn new(component: Box<dyn Any>, component_name: &'static str) -> Self
-    {
-        Self {
-            component: Lock::new(component, component_name),
-            name: component_name,
-        }
-    }
-
-    pub fn component(&self) -> &Lock<Box<dyn Any>>
-    {
-        &self.component
-    }
-
-    pub fn name(&self) -> &str
-    {
-        self.name
-    }
-}
-
-/// Archetype ID.
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
-pub struct Id
-{
-    hash: u64,
-}
-
-impl Id
-{
-    pub fn new_empty() -> Self
-    {
-        Self { hash: 0 }
-    }
-
-    pub fn new<'a>(component_ids: impl IntoIterator<Item = &'a Uid>) -> Self
-    {
-        let mut hasher = DefaultHasher::new();
-
-        let mut prev_component_id: Option<Uid> = None;
-
-        let mut component_id_iter = component_ids.into_iter().peekable();
-
-        if component_id_iter.peek().is_none() {
-            return Self::new_empty();
-        }
-
-        for comp_id in component_id_iter {
-            assert!(
-                prev_component_id.is_none_or(|prev_comp_id| *comp_id >= prev_comp_id),
-                "Cannot create archetype ID from a unsorted component metadata list"
-            );
-
-            prev_component_id = Some(*comp_id);
-
-            comp_id.hash(&mut hasher);
-        }
-
-        Self { hash: hasher.finish() }
-    }
-}
diff --git a/ecs/src/component/storage/graph.rs b/ecs/src/component/storage/graph.rs
deleted file mode 100644
index 76200f9..0000000
--- a/ecs/src/component/storage/graph.rs
+++ /dev/null
@@ -1,432 +0,0 @@
-use std::vec::IntoIter as VecIntoIter;
-
-use hashbrown::{HashMap, HashSet};
-
-use crate::component::storage::archetype::{Archetype, Id as ArchetypeId};
-use crate::uid::{Kind as UidKind, Uid};
-use crate::util::{BorrowedOrOwned, StreamingIterator};
-
-#[derive(Debug, Default)]
-pub struct Graph
-{
-    nodes: Vec<ArchetypeNode>,
-    archetype_index_lookup: HashMap<ArchetypeId, usize>,
-}
-
-impl Graph
-{
-    pub fn create_node(&mut self, id: ArchetypeId, component_ids: &impl AsRef<[Uid]>)
-    {
-        debug_assert!(!self.contains_archetype(id));
-
-        let _ = self.get_or_create_node(id, component_ids);
-    }
-
-    pub fn get_or_create_node(
-        &mut self,
-        id: ArchetypeId,
-        component_ids: &impl AsRef<[Uid]>,
-    ) -> &mut ArchetypeNode
-    {
-        let exists_before = self.archetype_index_lookup.contains_key(&id);
-
-        let index = *self.archetype_index_lookup.entry(id).or_insert_with(|| {
-            self.nodes.push(ArchetypeNode {
-                archetype: Archetype::new(id, component_ids.as_ref()),
-                edges: HashMap::new(),
-            });
-
-            self.nodes.len() - 1
-        });
-
-        if !exists_before {
-            self.create_missing_edges(id);
-        }
-
-        self.nodes
-            .get_mut(index)
-            .expect("Archetype index from lookup is out of bounds")
-    }
-
-    pub fn contains_archetype(&self, id: ArchetypeId) -> bool
-    {
-        self.archetype_index_lookup.contains_key(&id)
-    }
-
-    pub fn get_node_by_id(&self, id: ArchetypeId) -> Option<&ArchetypeNode>
-    {
-        let index = self.archetype_index_lookup.get(&id)?;
-
-        Some(self.nodes.get(*index).unwrap_or_else(|| {
-            panic!("In invalid state! Index of archetype with ID {id:?} is out of bounds")
-        }))
-    }
-
-    pub fn get_node_by_id_mut(&mut self, id: ArchetypeId) -> Option<&mut ArchetypeNode>
-    {
-        let index = self.archetype_index_lookup.get(&id)?;
-
-        Some(self.nodes.get_mut(*index).unwrap_or_else(|| {
-            panic!("In invalid state! Index of archetype with ID {id:?} is out of bounds")
-        }))
-    }
-
-    #[cfg(feature = "vizoxide")]
-    pub fn iter_nodes(&self) -> impl Iterator<Item = &ArchetypeNode>
-    {
-        self.nodes.iter()
-    }
-
-    pub fn dfs_archetype_add_edges(
-        &self,
-        archetype_id: ArchetypeId,
-    ) -> Option<ArchetypeAddEdgeDfsIter<'_>>
-    {
-        let node = self.get_node_by_id(archetype_id)?;
-
-        Some(ArchetypeAddEdgeDfsIter {
-            graph: self,
-            stack: vec![(
-                BorrowedOrOwned::Borrowned(node.archetype()),
-                node.edges
-                    .iter()
-                    .map(|(comp_id, edges)| (*comp_id, edges.clone()))
-                    .collect::<Vec<_>>()
-                    .into_iter(),
-            )],
-            visited: HashSet::new(),
-        })
-    }
-
-    fn create_missing_edges(&mut self, archetype_id: ArchetypeId)
-    {
-        let archetype_node_index = *self
-            .archetype_index_lookup
-            .get(&archetype_id)
-            .expect("Archetype should exist");
-
-        let (nodes_before, nodes_rest) = self.nodes.split_at_mut(archetype_node_index);
-
-        let ([archetype_node], nodes_after) = nodes_rest.split_at_mut(1) else {
-            unreachable!();
-        };
-
-        for other_archetype_node in nodes_before.iter_mut().chain(nodes_after.iter_mut())
-        {
-            if archetype_node.archetype().component_cnt()
-                > other_archetype_node.archetype().component_cnt()
-                && other_archetype_node
-                    .archetype()
-                    .is_subset(archetype_node.archetype())
-            {
-                Self::create_missing_subset_node_edges(
-                    archetype_node,
-                    other_archetype_node,
-                );
-
-                continue;
-            }
-
-            if other_archetype_node
-                .archetype()
-                .is_superset(archetype_node.archetype())
-            {
-                Self::create_missing_superset_node_edges(
-                    archetype_node,
-                    other_archetype_node,
-                );
-            }
-        }
-    }
-
-    fn create_missing_subset_node_edges(
-        target_node: &mut ArchetypeNode,
-        subset_node: &mut ArchetypeNode,
-    )
-    {
-        let uniq_comp_id = target_node
-            .archetype()
-            .component_ids_sorted()
-            .find(|id| {
-                !subset_node
-                    .archetype()
-                    .contains_component_with_exact_id(*id)
-            })
-            .unwrap();
-
-        subset_node
-            .get_or_insert_edges(uniq_comp_id, ArchetypeEdges::default)
-            .add = Some(subset_node.make_add_edge(uniq_comp_id).0);
-
-        if target_node.archetype().component_cnt()
-            == subset_node.archetype().component_cnt() + 1
-        {
-            target_node
-                .get_or_insert_edges(uniq_comp_id, ArchetypeEdges::default)
-                .remove = Some(subset_node.archetype().id());
-        }
-    }
-
-    fn create_missing_superset_node_edges(
-        target_node: &mut ArchetypeNode,
-        superset_node: &mut ArchetypeNode,
-    )
-    {
-        if superset_node.archetype().component_cnt()
-            > target_node.archetype().component_cnt() + 1
-        {
-            let first_unique_comp_id = superset_node
-                .archetype()
-                .component_ids_sorted()
-                .find(|other_archetype_comp_id| {
-                    !target_node
-                        .archetype()
-                        .contains_component_with_exact_id(*other_archetype_comp_id)
-                })
-                .or_else(|| {
-                    if target_node.archetype().component_cnt() != 0 {
-                        return None;
-                    }
-
-                    superset_node.archetype().component_ids_sorted().next()
-                })
-                .expect("Not possible");
-
-            target_node
-                .get_or_insert_edges(first_unique_comp_id, ArchetypeEdges::default)
-                .add = Some(target_node.make_add_edge(first_unique_comp_id).0);
-
-            return;
-        }
-
-        if superset_node.archetype().component_cnt()
-            != target_node.archetype().component_cnt() + 1
-        {
-            return;
-        }
-
-        let extra_comp_id = superset_node
-            .archetype()
-            .component_ids_unsorted()
-            .find(|comp_id| {
-                !target_node
-                    .archetype()
-                    .contains_component_with_exact_id(*comp_id)
-            })
-            .expect("Archetype should contain one extra component ID");
-
-        superset_node
-            .get_or_insert_edges(extra_comp_id, ArchetypeEdges::default)
-            .remove = Some(target_node.archetype().id());
-
-        target_node
-            .get_or_insert_edges(extra_comp_id, ArchetypeEdges::default)
-            .add = Some(superset_node.archetype().id());
-    }
-}
-
-#[derive(Debug)]
-pub struct ArchetypeNode
-{
-    archetype: Archetype,
-    edges: HashMap<Uid, ArchetypeEdges>,
-}
-
-impl ArchetypeNode
-{
-    pub fn archetype(&self) -> &Archetype
-    {
-        &self.archetype
-    }
-
-    pub fn archetype_mut(&mut self) -> &mut Archetype
-    {
-        &mut self.archetype
-    }
-
-    pub fn get_or_insert_edges(
-        &mut self,
-        component_id: Uid,
-        insert_fn: impl FnOnce() -> ArchetypeEdges,
-    ) -> &mut ArchetypeEdges
-    {
-        debug_assert!(matches!(
-            component_id.kind(),
-            UidKind::Component | UidKind::Pair
-        ));
-
-        self.edges.entry(component_id).or_insert_with(insert_fn)
-    }
-
-    #[cfg(feature = "vizoxide")]
-    pub fn iter_edges(&self) -> impl Iterator<Item = (&Uid, &ArchetypeEdges)>
-    {
-        self.edges.iter()
-    }
-
-    pub fn make_add_edge(&self, component_id: Uid) -> (ArchetypeId, Vec<Uid>)
-    {
-        let mut edge_comp_ids = self
-            .archetype()
-            .component_ids_unsorted()
-            .chain([component_id])
-            .collect::<Vec<_>>();
-
-        edge_comp_ids.sort();
-
-        let add_edge_id = ArchetypeId::new(&edge_comp_ids);
-
-        (add_edge_id, edge_comp_ids)
-    }
-
-    pub fn make_remove_edge(&self, component_id: Uid) -> (ArchetypeId, Vec<Uid>)
-    {
-        let mut edge_comp_ids = self
-            .archetype()
-            .component_ids_unsorted()
-            .filter(|id| *id != component_id)
-            .collect::<Vec<_>>();
-
-        edge_comp_ids.sort();
-
-        let remove_edge_id = ArchetypeId::new(&edge_comp_ids);
-
-        (remove_edge_id, edge_comp_ids)
-    }
-}
-
-#[derive(Debug, Default, Clone)]
-pub struct ArchetypeEdges
-{
-    pub add: Option<ArchetypeId>,
-    pub remove: Option<ArchetypeId>,
-}
-
-type ArchetypeAddEdgeDfsIterStackElem<'graph> = (
-    BorrowedOrOwned<'graph, Archetype>,
-    VecIntoIter<(Uid, ArchetypeEdges)>,
-);
-
-#[derive(Debug)]
-pub struct ArchetypeAddEdgeDfsIter<'graph>
-{
-    graph: &'graph Graph,
-    stack: Vec<ArchetypeAddEdgeDfsIterStackElem<'graph>>,
-    visited: HashSet<ArchetypeId>,
-}
-
-impl<'graph> ArchetypeAddEdgeDfsIter<'graph>
-{
-    pub fn new(graph: &'graph Graph, start_nodes: &[ArchetypeId]) -> Self
-    {
-        Self {
-            graph,
-            stack: start_nodes
-                .iter()
-                .map(|start_node_id| {
-                    let start_node = graph
-                        .get_node_by_id(*start_node_id)
-                        .expect("Start node does not exist");
-
-                    (
-                        BorrowedOrOwned::Borrowned(start_node.archetype()),
-                        start_node
-                            .edges
-                            .iter()
-                            .map(|(comp_id, edges)| (*comp_id, edges.clone()))
-                            .collect::<Vec<_>>()
-                            .into_iter(),
-                    )
-                })
-                .collect(),
-            visited: start_nodes.iter().copied().collect::<HashSet<_>>(),
-        }
-    }
-
-    pub fn push(
-        &mut self,
-        item: (
-            BorrowedOrOwned<'graph, Archetype>,
-            VecIntoIter<(Uid, ArchetypeEdges)>,
-        ),
-    )
-    {
-        self.stack.push(item);
-    }
-
-    pub fn pop(&mut self)
-    {
-        self.stack.pop();
-    }
-}
-
-impl<'graph> StreamingIterator for ArchetypeAddEdgeDfsIter<'graph>
-{
-    type Item<'a>
-        = ArchetypeAddEdgeDfsIterResult<'graph, 'a>
-    where
-        Self: 'a;
-
-    fn streaming_next(&mut self) -> Option<Self::Item<'_>>
-    {
-        let (_, edges_iter) = self.stack.last_mut()?;
-
-        let Some((component_id, edges)) = edges_iter.next() else {
-            self.stack.pop();
-
-            return Some(ArchetypeAddEdgeDfsIterResult::NoEdgesLeftForArchetype);
-        };
-
-        let Some(add_edge) = edges.add else {
-            return Some(ArchetypeAddEdgeDfsIterResult::NoAddEdge);
-        };
-
-        if self.visited.contains(&add_edge) {
-            return Some(ArchetypeAddEdgeDfsIterResult::AddEdgeAlreadyVisited);
-        }
-
-        self.visited.insert(add_edge);
-
-        let Some(add_edge_archetype) = self.graph.get_node_by_id(add_edge) else {
-            return Some(ArchetypeAddEdgeDfsIterResult::AddEdgeArchetypeNotFound {
-                archetype: &self.stack.last().unwrap().0,
-                add_edge_archetype_id: add_edge,
-                add_edge_component_id: component_id,
-            });
-        };
-
-        self.stack.push((
-            BorrowedOrOwned::Borrowned(add_edge_archetype.archetype()),
-            add_edge_archetype
-                .edges
-                .iter()
-                .map(|(comp_id, edges)| (*comp_id, edges.clone()))
-                .collect::<Vec<_>>()
-                .into_iter(),
-        ));
-
-        Some(ArchetypeAddEdgeDfsIterResult::AddEdge {
-            add_edge_archetype_id: add_edge,
-            add_edge_component_id: component_id,
-        })
-    }
-}
-
-#[derive(Debug)]
-pub enum ArchetypeAddEdgeDfsIterResult<'graph, 'iter>
-{
-    AddEdge
-    {
-        add_edge_archetype_id: ArchetypeId,
-        add_edge_component_id: Uid,
-    },
-    NoEdgesLeftForArchetype,
-    NoAddEdge,
-    AddEdgeAlreadyVisited,
-    AddEdgeArchetypeNotFound
-    {
-        archetype: &'iter BorrowedOrOwned<'graph, Archetype>,
-        add_edge_archetype_id: ArchetypeId,
-        add_edge_component_id: Uid,
-    },
-}
diff --git a/ecs/src/entity.rs b/ecs/src/entity.rs
deleted file mode 100644
index ad9f179..0000000
--- a/ecs/src/entity.rs
+++ /dev/null
@@ -1,295 +0,0 @@
-use std::any::type_name;
-use std::ops::Deref;
-use std::sync::LazyLock;
-
-use crate::component::storage::archetype::{
-    Archetype,
-    Entity as ArchetypeEntity,
-    MatchingComponentIter as ArchetypeMatchingComponentIter,
-};
-use crate::component::{
-    Component,
-    Handle as ComponentHandle,
-    HandleMut as ComponentHandleMut,
-};
-use crate::pair::{
-    ComponentOrWildcard,
-    MultipleWithWildcard as PairMultipleWithWildcard,
-    Pair,
-    WithWildcard as PairWithWildcard,
-};
-use crate::uid::{Kind as UidKind, Uid};
-use crate::{EntityComponentRef, World};
-
-pub mod obtainer;
-
-/// A handle to a entity.
-#[derive(Debug, Clone)]
-pub struct Handle<'a>
-{
-    archetype: &'a Archetype,
-    entity: &'a ArchetypeEntity,
-    world: &'a World,
-}
-
-impl<'a> Handle<'a>
-{
-    /// Returns the [`Uid`] of this entity.
-    #[inline]
-    #[must_use]
-    pub fn uid(&self) -> Uid
-    {
-        self.entity.uid()
-    }
-
-    /// Returns a reference to the specified component in this entity. `None` is
-    /// returned if the component isn't found in the entity.
-    ///
-    /// # Panics
-    /// Will panic if:
-    /// - The component's ID is not a component ID
-    /// - The component is mutably borrowed elsewhere
-    #[must_use]
-    pub fn get<ComponentT: Component>(&self) -> Option<ComponentHandle<'a, ComponentT>>
-    {
-        assert_eq!(ComponentT::id().kind(), UidKind::Component);
-
-        let component = self.get_matching_components(ComponentT::id()).next()?;
-
-        Some(
-            ComponentHandle::from_entity_component_ref(&component).unwrap_or_else(
-                |err| {
-                    panic!(
-                        "Creating handle to component {} failed: {err}",
-                        type_name::<ComponentT>()
-                    );
-                },
-            ),
-        )
-    }
-
-    /// Returns a mutable reference to the specified component in this entity. `None` is
-    /// returned if the component isn't found in the entity.
-    ///
-    /// # Panics
-    /// Will panic if:
-    /// - The component's ID is not a component ID
-    /// - The component is borrowed elsewhere
-    #[must_use]
-    pub fn get_mut<ComponentT: Component>(
-        &self,
-    ) -> Option<ComponentHandleMut<'a, ComponentT>>
-    {
-        assert_eq!(ComponentT::id().kind(), UidKind::Component);
-
-        let component = self.get_matching_components(ComponentT::id()).next()?;
-
-        Some(
-            ComponentHandleMut::from_entity_component_ref(&component, self.world)
-                .unwrap_or_else(|err| {
-                    panic!(
-                        "Creating handle to component {} failed: {err}",
-                        type_name::<ComponentT>()
-                    );
-                }),
-        )
-    }
-
-    /// Returns a reference to the component with the ID `id` in this entity.
-    /// `None` is returned if the component isn't found.
-    ///
-    /// # Panics
-    /// Will panic if:
-    /// - The ID is not a component/pair ID
-    /// - The component is borrowed mutably elsewhere
-    /// - The component type is incorrect
-    #[must_use]
-    pub fn get_with_id<ComponentDataT: 'static>(
-        &self,
-        id: Uid,
-    ) -> Option<ComponentHandle<'a, ComponentDataT>>
-    {
-        assert!(
-            matches!(id.kind(), UidKind::Component | UidKind::Pair),
-            "ID {id:?} is not a component/pair ID"
-        );
-
-        let component = self.get_matching_components(id).next()?;
-
-        Some(
-            ComponentHandle::from_entity_component_ref(&component).unwrap_or_else(
-                |err| {
-                    panic!(
-                        "Creating handle to component {} failed: {err}",
-                        type_name::<ComponentDataT>()
-                    );
-                },
-            ),
-        )
-    }
-
-    /// Returns a mutable reference to the component with the ID `id` in this entity.
-    /// `None` is returned if the component isn't found.
-    ///
-    /// # Panics
-    /// Will panic if:
-    /// - The ID is not a component/pair ID
-    /// - The component is borrowed elsewhere
-    /// - The component type is incorrect
-    #[must_use]
-    pub fn get_with_id_mut<ComponentDataT: 'static>(
-        &self,
-        id: Uid,
-    ) -> Option<ComponentHandleMut<'a, ComponentDataT>>
-    {
-        assert!(
-            matches!(id.kind(), UidKind::Component | UidKind::Pair),
-            "ID {id:?} is not a component/pair ID"
-        );
-
-        let component = self.get_matching_components(id).next()?;
-
-        Some(
-            ComponentHandleMut::from_entity_component_ref(&component, self.world)
-                .unwrap_or_else(|err| {
-                    panic!(
-                        "Creating handle to component {} failed: {err}",
-                        type_name::<ComponentDataT>()
-                    );
-                }),
-        )
-    }
-
-    #[must_use]
-    pub fn get_first_wildcard_pair_match<Relation, Target>(
-        &self,
-    ) -> Option<PairWithWildcard<'a, Relation, Target>>
-    where
-        Relation: ComponentOrWildcard,
-        Target: ComponentOrWildcard,
-    {
-        let mut matching_comps = self.get_matching_components(
-            Pair::builder()
-                .relation_id(Relation::uid())
-                .target_id(Target::uid())
-                .build()
-                .id(),
-        );
-
-        Some(PairWithWildcard::new(self.world, matching_comps.next()?))
-    }
-
-    #[must_use]
-    pub fn get_wildcard_pair_matches<Relation, Target>(
-        &self,
-    ) -> PairMultipleWithWildcard<'a, Relation, Target>
-    where
-        Relation: ComponentOrWildcard,
-        Target: ComponentOrWildcard,
-    {
-        PairMultipleWithWildcard::new(self.world, self.clone())
-    }
-
-    #[inline]
-    #[must_use]
-    pub fn get_matching_components(&self, component_uid: Uid)
-        -> MatchingComponentIter<'a>
-    {
-        MatchingComponentIter {
-            inner: self.archetype.get_matching_component_indices(component_uid),
-            entity: self.entity,
-        }
-    }
-
-    /// Returns whether or not this entity contains a component with the specified `Uid`.
-    #[must_use]
-    pub fn has_component(&self, component_uid: Uid) -> bool
-    {
-        self.archetype
-            .contains_component_with_exact_id(component_uid)
-    }
-
-    /// Returns the `Uids`s of the components this entity has.
-    pub fn component_ids(&self) -> impl Iterator<Item = Uid> + '_
-    {
-        self.archetype.component_ids_sorted()
-    }
-
-    pub(crate) fn new(
-        archetype: &'a Archetype,
-        entity: &'a ArchetypeEntity,
-        world: &'a World,
-    ) -> Self
-    {
-        Self { archetype, entity, world }
-    }
-}
-
-#[derive(Debug)]
-pub struct MatchingComponentIter<'a>
-{
-    inner: ArchetypeMatchingComponentIter<'a>,
-    entity: &'a ArchetypeEntity,
-}
-
-impl<'a> Iterator for MatchingComponentIter<'a>
-{
-    type Item = EntityComponentRef<'a>;
-
-    fn next(&mut self) -> Option<Self::Item>
-    {
-        let (matching_component_id, index) = self.inner.next()?;
-
-        Some(EntityComponentRef::new(
-            matching_component_id,
-            self.entity.components().get(index).unwrap(),
-            self.entity.uid(),
-        ))
-    }
-}
-
-/// The data type of a declaration of a entity.
-#[derive(Debug)]
-pub struct Declaration
-{
-    uid: LazyLock<Uid>,
-    create_func: fn(&mut World),
-}
-
-impl Declaration
-{
-    pub(crate) fn create(&self, world: &mut World)
-    {
-        (self.create_func)(world);
-    }
-
-    #[doc(hidden)]
-    pub const fn new(create_func: fn(&mut World)) -> Self
-    {
-        Self {
-            uid: LazyLock::new(|| Uid::new_unique(UidKind::Entity)),
-            create_func,
-        }
-    }
-}
-
-impl Deref for Declaration
-{
-    type Target = Uid;
-
-    fn deref(&self) -> &Self::Target
-    {
-        &self.uid
-    }
-}
-
-#[allow(clippy::module_name_repetitions)]
-#[macro_export]
-macro_rules! declare_entity {
-    ($visibility: vis $ident: ident, $components: expr) => {
-        $visibility static $ident: $crate::entity::Declaration =
-            $crate::entity::Declaration::new(|world| {
-                world.create_entity_with_uid(*$ident, $components);
-            });
-    }
-}
diff --git a/ecs/src/entity/obtainer.rs b/ecs/src/entity/obtainer.rs
deleted file mode 100644
index 6c2ea96..0000000
--- a/ecs/src/entity/obtainer.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-use crate::entity::Handle as EntityHandle;
-use crate::system::{Metadata as SystemMetadata, Param as SystemParam};
-use crate::uid::Uid;
-use crate::World;
-
-#[derive(Debug)]
-pub struct Obtainer<'world>
-{
-    world: &'world World,
-}
-
-impl<'world> SystemParam<'world> for Obtainer<'world>
-{
-    type Input = ();
-
-    fn new(world: &'world World, _system_metadata: &SystemMetadata) -> Self
-    {
-        Self { world }
-    }
-}
-
-impl Obtainer<'_>
-{
-    #[must_use]
-    pub fn get_entity(&self, entity_id: Uid) -> Option<EntityHandle<'_>>
-    {
-        self.world.get_entity(entity_id)
-    }
-}
diff --git a/ecs/src/error.rs b/ecs/src/error.rs
deleted file mode 100644
index 185b706..0000000
--- a/ecs/src/error.rs
+++ /dev/null
@@ -1,270 +0,0 @@
-use std::fmt::{Debug, Display, Write as _};
-
-use backtrace::Backtrace;
-
-#[macro_export]
-macro_rules! error {
-    ($lit: literal) => {
-        $crate::error::Error::from($lit)
-    };
-
-    ($lit: literal, $($tt: tt)*) => {
-        $crate::error::Error::from(std::format!($lit, $($tt)*))
-    };
-
-    ($err: expr) => {
-        $crate::error::Error::from($err)
-    };
-}
-
-pub struct Error
-{
-    inner: Box<dyn std::error::Error + Send + Sync>,
-    backtrace: Backtrace,
-}
-
-impl Error
-{
-    pub fn resolve_backtrace(&mut self)
-    {
-        self.backtrace.resolve();
-    }
-
-    fn is_backtrace_resolved(&self) -> bool
-    {
-        let Some(first_frame) = self.backtrace.frames().first() else {
-            return false;
-        };
-
-        !first_frame.symbols().is_empty()
-    }
-}
-
-impl Debug for Error
-{
-    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
-    {
-        let error = &*self.inner;
-
-        write!(formatter, "{error}")?;
-
-        if let Some(cause) = error.source() {
-            write!(formatter, "\n\nCaused by:")?;
-            let multiple = cause.source().is_some();
-            for (n, error) in anyhow::Chain::new(cause).enumerate() {
-                writeln!(formatter)?;
-
-                let mut indented = Indented {
-                    inner: formatter,
-                    number: if multiple { Some(n) } else { None },
-                    started: false,
-                };
-                write!(indented, "{error}")?;
-            }
-        }
-
-        if std::env::var_os("ENGINE_ECS_BACKTRACE")
-            .is_none_or(|backtrace_enabled| backtrace_enabled != "1")
-        {
-            write!(
-                formatter,
-                concat!(
-                    "\n\nnote: run with `ENGINE_ECS_BACKTRACE=1` environment variable ",
-                    "to display a engine backtrace"
-                )
-            )?;
-
-            return Ok(());
-        }
-
-        let mut cloned_backtrace;
-
-        let backtrace = if self.is_backtrace_resolved() {
-            &self.backtrace
-        } else {
-            cloned_backtrace = self.backtrace.clone();
-            cloned_backtrace.resolve();
-            &cloned_backtrace
-        };
-
-        write!(
-            formatter,
-            "\n\nStack backtrace:\n{:?}",
-            std::fmt::from_fn(|backtrace_formatter| fmt_backtrace(
-                backtrace,
-                backtrace_formatter
-            ))
-        )?;
-
-        Ok(())
-    }
-}
-
-impl Display for Error
-{
-    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
-    {
-        let error = &*self.inner;
-
-        write!(formatter, "{error}")?;
-
-        if formatter.alternate() {
-            let chain = anyhow::Chain::new(error);
-            for cause in chain.skip(1) {
-                write!(formatter, ": {}", cause)?;
-            }
-        }
-
-        Ok(())
-    }
-}
-
-impl<Err: Send + Sync + 'static> From<Err> for Error
-where
-    Box<dyn std::error::Error + Send + Sync>: From<Err>,
-{
-    fn from(err: Err) -> Self
-    {
-        Self {
-            inner: err.into(),
-            backtrace: Backtrace::new_unresolved(),
-        }
-    }
-}
-
-pub type ErrorHandler = fn(Error, Metadata);
-
-/// Error metadata.
-#[derive(Debug)]
-pub struct Metadata
-{
-    pub source_name: &'static str,
-    pub source_kind: SourceKind,
-}
-
-/// Error source kind.
-#[derive(Debug)]
-#[non_exhaustive]
-pub enum SourceKind
-{
-    System,
-    Observer,
-}
-
-impl Display for SourceKind
-{
-    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
-    {
-        match self {
-            SourceKind::System => formatter.write_str("system"),
-            SourceKind::Observer => formatter.write_str("observer"),
-        }
-    }
-}
-
-pub fn err_handler_panic(mut err: Error, err_metadata: Metadata)
-{
-    err.resolve_backtrace();
-
-    panic!(
-        "Error occurred in {} '{}': {err:?}",
-        err_metadata.source_kind, err_metadata.source_name
-    );
-}
-
-pub fn err_handler_log_error(err: Error, err_metadata: Metadata)
-{
-    tracing::error!(
-        "Error occurred in {} '{}': {err:#}",
-        err_metadata.source_kind,
-        err_metadata.source_name
-    );
-}
-
-fn fmt_backtrace(
-    backtrace: &Backtrace,
-    fmt: &mut std::fmt::Formatter<'_>,
-) -> std::fmt::Result
-{
-    let style = if fmt.alternate() {
-        backtrace::PrintFmt::Full
-    } else {
-        backtrace::PrintFmt::Short
-    };
-
-    // When printing paths we try to strip the cwd if it exists, otherwise
-    // we just print the path as-is. Note that we also only do this for the
-    // short format, because if it's full we presumably want to print
-    // everything.
-    let cwd = std::env::current_dir();
-    let mut print_path =
-        move |fmt: &mut std::fmt::Formatter<'_>,
-              path: backtrace::BytesOrWideString<'_>| {
-            let path = path.into_path_buf();
-            if style != backtrace::PrintFmt::Full {
-                if let Ok(cwd) = &cwd {
-                    if let Ok(suffix) = path.strip_prefix(cwd) {
-                        return std::fmt::Display::fmt(&suffix.display(), fmt);
-                    }
-                }
-            }
-            std::fmt::Display::fmt(&path.display(), fmt)
-        };
-
-    let mut f = backtrace::BacktraceFmt::new(fmt, style, &mut print_path);
-
-    f.add_context()?;
-
-    for frame in backtrace.frames() {
-        if frame.symbols().iter().all(|symbol| {
-            symbol.name().is_some_and(|symbol_name| {
-                let symbol_name = symbol_name.to_string();
-
-                symbol_name
-                    .contains("<ecs::error::Error as core::convert::From<Err>>::from")
-            })
-        }) {
-            continue;
-        }
-
-        f.frame().backtrace_frame(frame)?;
-    }
-    f.finish()?;
-    Ok(())
-}
-
-struct Indented<'a, D>
-{
-    inner: &'a mut D,
-    number: Option<usize>,
-    started: bool,
-}
-
-impl<T> std::fmt::Write for Indented<'_, T>
-where
-    T: std::fmt::Write,
-{
-    fn write_str(&mut self, s: &str) -> std::fmt::Result
-    {
-        for (i, line) in s.split('\n').enumerate() {
-            if !self.started {
-                self.started = true;
-                match self.number {
-                    Some(number) => write!(self.inner, "{: >5}: ", number)?,
-                    None => self.inner.write_str("    ")?,
-                }
-            } else if i > 0 {
-                self.inner.write_char('\n')?;
-                if self.number.is_some() {
-                    self.inner.write_str("       ")?;
-                } else {
-                    self.inner.write_str("    ")?;
-                }
-            }
-
-            self.inner.write_str(line)?;
-        }
-
-        Ok(())
-    }
-}
diff --git a/ecs/src/event.rs b/ecs/src/event.rs
deleted file mode 100644
index 15455b6..0000000
--- a/ecs/src/event.rs
+++ /dev/null
@@ -1,105 +0,0 @@
-use crate::lock::Lock;
-use crate::pair::Pair;
-use crate::uid::{Kind as UidKind, Uid};
-use crate::util::VecExt;
-
-pub mod component;
-
-#[derive(Debug, Clone)]
-#[non_exhaustive]
-pub struct Emitted<'a>
-{
-    pub event: Uid,
-    pub match_ids: &'a [Uid],
-}
-
-#[derive(Debug)]
-pub struct Submitter<'world>
-{
-    new_events: &'world Lock<NewEvents>,
-}
-
-impl<'world> Submitter<'world>
-{
-    /// Submits a event to be handled later.
-    ///
-    /// # Panics
-    /// Will panic if unable to acquire a read-write lock to the event store.
-    pub fn submit_event(&self, event: &Pair<Uid, Uid>, match_id: Uid)
-    {
-        let mut new_events_lock = self
-            .new_events
-            .write_nonblock()
-            .expect("Failed to acquire read-write lock to new events");
-
-        new_events_lock.push_event_match(event, match_id);
-    }
-
-    pub(crate) fn new(new_events: &'world Lock<NewEvents>) -> Self
-    {
-        Self { new_events }
-    }
-}
-
-#[derive(Debug, Default)]
-pub(crate) struct NewEvents
-{
-    events: Vec<(Uid, Matches)>,
-}
-
-impl NewEvents
-{
-    pub fn push_event_match(&mut self, event: &Pair<Uid, Uid>, match_id: Uid)
-    {
-        let event_id = event.id();
-
-        assert_eq!(event_id.kind(), UidKind::Pair);
-
-        if let Ok(event_index) = self
-            .events
-            .binary_search_by_key(&event_id, |(other_event_id, _)| *other_event_id)
-        {
-            let Some((_, matches)) = self.events.get_mut(event_index) else {
-                unreachable!();
-            };
-
-            matches.sorted_push(match_id);
-
-            return;
-        }
-
-        self.events.insert_at_part_pt_by_key(
-            (event_id, Matches { match_ids: Vec::from([match_id]) }),
-            |(other_event_id, _)| other_event_id,
-        );
-    }
-
-    pub fn take(&mut self) -> Vec<(Uid, Matches)>
-    {
-        std::mem::take(&mut self.events)
-    }
-
-    pub fn is_empty(&self) -> bool
-    {
-        self.events.is_empty()
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct Matches
-{
-    pub match_ids: Vec<Uid>,
-}
-
-impl Matches
-{
-    fn sorted_push(&mut self, match_id: Uid)
-    {
-        if self.match_ids.binary_search(&match_id).is_ok() {
-            return;
-        }
-
-        self.match_ids
-            .insert_at_part_pt_by_key(match_id, |other_match_id| other_match_id);
-    }
-}
diff --git a/ecs/src/event/component.rs b/ecs/src/event/component.rs
deleted file mode 100644
index 70ea3e5..0000000
--- a/ecs/src/event/component.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-//! Component events.
-
-use std::convert::Infallible;
-
-use crate::Component;
-use crate::component::{Handle as ComponentHandle, HandleMut as ComponentHandleMut};
-use crate::entity::Handle as EntityHandle;
-use crate::pair::Pair;
-use crate::system::observer::{EventMatch, Observed};
-
-/// Implemented by the relations of component event pairs
-pub trait EventRelation: Component {}
-
-/// Pair relation for events emitted when:
-/// a) A entity with the target component is spawned.
-/// b) The target component is added to a entity.
-#[derive(Debug, Component)]
-pub struct Added(Infallible);
-
-impl EventRelation for Added {}
-
-/// Pair relation for events emitted **before**:
-/// a) The target component is removed from a entity.
-/// b) A entity with the target component is despawned.
-#[derive(Debug, Component)]
-pub struct Removed(Infallible);
-
-impl EventRelation for Removed {}
-
-#[derive(Debug, Component)]
-pub struct Changed(Infallible);
-
-impl EventRelation for Changed {}
-
-/// [`EventMatch`] extension trait for component event matches.
-pub trait EventMatchExt<Target>: sealed::Sealed
-{
-    #[must_use]
-    fn get_entity(&self) -> EntityHandle<'_>;
-
-    #[must_use]
-    fn get_ent_target_comp(&self) -> ComponentHandle<'_, Target>
-    where
-        Target: Component;
-
-    #[must_use]
-    fn get_ent_target_comp_mut(&self) -> ComponentHandleMut<'_, Target>
-    where
-        Target: Component;
-}
-
-impl<ComponentEventRelation: EventRelation, Target> EventMatchExt<Target>
-    for EventMatch<'_, Pair<ComponentEventRelation, Target>>
-where
-    Pair<ComponentEventRelation, Target>: Observed,
-{
-    fn get_entity(&self) -> EntityHandle<'_>
-    {
-        let Some(ent) = self.try_get_entity() else {
-            unreachable!();
-        };
-
-        ent
-    }
-
-    fn get_ent_target_comp(&self) -> ComponentHandle<'_, Target>
-    where
-        Target: Component,
-    {
-        let ent = self.get_entity();
-
-        let Some(comp) = ent.get::<Target>() else {
-            unreachable!();
-        };
-
-        comp
-    }
-
-    fn get_ent_target_comp_mut(&self) -> ComponentHandleMut<'_, Target>
-    where
-        Target: Component,
-    {
-        let ent = self.get_entity();
-
-        let Some(comp) = ent.get_mut::<Target>() else {
-            unreachable!();
-        };
-
-        comp
-    }
-}
-
-impl<ComponentEventRelation: EventRelation, Target> sealed::Sealed
-    for EventMatch<'_, Pair<ComponentEventRelation, Target>>
-where
-    Pair<ComponentEventRelation, Target>: Observed,
-{
-}
-
-mod sealed
-{
-    pub trait Sealed {}
-}
diff --git a/ecs/src/extension.rs b/ecs/src/extension.rs
deleted file mode 100644
index 9c6614b..0000000
--- a/ecs/src/extension.rs
+++ /dev/null
@@ -1,72 +0,0 @@
-use crate::component::Sequence as ComponentSequence;
-use crate::entity::Declaration as EntityDeclaration;
-use crate::sole::Sole;
-use crate::system::observer::Observer;
-use crate::system::System;
-use crate::uid::Uid;
-use crate::{SoleAlreadyExistsError, World};
-
-/// A collection of systems, entities & soles that can be added to a [`World`].
-pub trait Extension
-{
-    fn collect(self, collector: Collector<'_>);
-}
-
-/// Passed to a [`Extension`] to collects it's systems, entities & soles.
-pub struct Collector<'world>
-{
-    world: &'world mut World,
-}
-
-impl<'world> Collector<'world>
-{
-    /// Returns a new `Collector` for the given [`World`].
-    pub fn new(world: &'world mut World) -> Self
-    {
-        Self { world }
-    }
-
-    /// Adds a system to the [`World`].
-    pub fn add_system<'this, SystemImpl>(
-        &'this mut self,
-        phase_euid: Uid,
-        system: impl System<'this, SystemImpl>,
-    )
-    {
-        self.world.register_system(phase_euid, system);
-    }
-
-    /// Adds a observer system to the [`World`].
-    pub fn add_observer<'this, SystemImpl>(
-        &'this mut self,
-        observer: impl Observer<'this, SystemImpl>,
-    )
-    {
-        self.world.register_observer(observer);
-    }
-
-    /// Adds a entity to the [`World`].
-    pub fn add_entity<Comps>(&mut self, components: Comps)
-    where
-        Comps: ComponentSequence,
-    {
-        self.world.create_entity(components);
-    }
-
-    /// Adds a declared entity to the [`World`].
-    pub fn add_declared_entity(&mut self, entity_decl: &EntityDeclaration)
-    {
-        self.world.create_declared_entity(entity_decl);
-    }
-
-    /// Adds a globally shared singleton value to the [`World`].
-    ///
-    /// # Errors
-    /// Returns `Err` if this [`Sole`] has already been added.
-    pub fn add_sole<SoleT>(&mut self, sole: SoleT) -> Result<(), SoleAlreadyExistsError>
-    where
-        SoleT: Sole,
-    {
-        self.world.add_sole(sole)
-    }
-}
diff --git a/ecs/src/lib.rs b/ecs/src/lib.rs
deleted file mode 100644
index 667aa0e..0000000
--- a/ecs/src/lib.rs
+++ /dev/null
@@ -1,773 +0,0 @@
-#![deny(clippy::all, clippy::pedantic)]
-
-use std::any::{Any, TypeId, type_name};
-use std::fmt::Debug;
-use std::hint::cold_path;
-use std::mem::ManuallyDrop;
-use std::rc::Rc;
-use std::sync::Arc;
-use std::sync::atomic::{AtomicBool, Ordering};
-
-use hashbrown::HashMap;
-
-use crate::actions::Action;
-use crate::component::storage::archetype::EntityComponent as ArchetypeEntityComponent;
-use crate::component::storage::{EntityAlreadyExistsError, Storage as ComponentStorage};
-use crate::component::{
-    Component,
-    IntoParts as IntoComponentParts,
-    Parts as ComponentParts,
-    Sequence as ComponentSequence,
-};
-use crate::entity::{Declaration as EntityDeclaration, Handle as EntityHandle};
-use crate::error::{
-    ErrorHandler,
-    Metadata as ErrorMetadata,
-    SourceKind as ErrorSourceKind,
-    err_handler_panic,
-};
-use crate::event::component::Added;
-use crate::event::{Emitted as EmittedEvent, NewEvents, Submitter as EventSubmitter};
-use crate::extension::{Collector as ExtensionCollector, Extension};
-use crate::lock::Lock;
-use crate::pair::{ChildOf, Pair, Wildcard};
-use crate::phase::{
-    HasSystem as PhaseHasSystem,
-    POST_UPDATE as POST_UPDATE_PHASE,
-    PRE_UPDATE as PRE_UPDATE_PHASE,
-    Phase,
-    START as START_PHASE,
-    UPDATE as UPDATE_PHASE,
-};
-use crate::query::flexible::Query as FlexibleQuery;
-use crate::query::{
-    MAX_TERM_CNT as QUERY_MAX_TERM_CNT,
-    TermWithFieldTuple as QueryTermWithFieldTuple,
-    TermWithoutFieldTuple as QueryTermWithoutFieldTuple,
-    Terms as QueryTerms,
-    TermsBuilderInterface,
-};
-use crate::sole::{Single, Sole};
-use crate::stats::Stats;
-use crate::system::observer::{Observer, WrapperComponent as ObserverWrapperComponent};
-use crate::system::{Callbacks, Metadata as SystemMetadata, System, SystemComponent};
-use crate::uid::{Kind as UidKind, Uid};
-
-pub mod actions;
-pub mod component;
-pub mod entity;
-pub mod error;
-pub mod event;
-pub mod extension;
-pub mod pair;
-pub mod phase;
-pub mod query;
-pub mod sole;
-pub mod stats;
-pub mod system;
-pub mod tuple;
-pub mod uid;
-pub mod util;
-
-mod lock;
-
-pub use ecs_macros::{Component, Sole};
-
-pub use crate::query::Query;
-
-#[derive(Debug)]
-pub struct World
-{
-    data: WorldData,
-    stop: AtomicBool,
-    is_first_tick: AtomicBool,
-    error_handler: ErrorHandler,
-}
-
-impl World
-{
-    #[must_use]
-    pub fn new() -> Self
-    {
-        let mut world = Self {
-            data: WorldData::default(),
-            stop: AtomicBool::new(false),
-            is_first_tick: AtomicBool::new(false),
-            error_handler: err_handler_panic,
-        };
-
-        crate::phase::spawn_entities(&mut world);
-
-        world.add_sole(Stats::default()).ok();
-
-        world
-    }
-
-    pub fn set_err_handler(&mut self, err_handler: ErrorHandler)
-    {
-        self.error_handler = err_handler;
-    }
-
-    /// Creates a entity with the given components. A new unique [`Uid`] will be generated
-    /// for this entity.
-    pub fn create_entity<Comps>(&mut self, components: Comps) -> Uid
-    where
-        Comps: ComponentSequence,
-    {
-        let entity_uid = Uid::new_unique(UidKind::Entity);
-
-        self.create_entity_with_uid(entity_uid, components);
-
-        entity_uid
-    }
-
-    /// Creates a entity with the given components. The entity will have the specified
-    /// [`Uid`].
-    #[tracing::instrument(skip_all)]
-    pub fn create_entity_with_uid<Comps>(&mut self, entity_uid: Uid, components: Comps)
-    where
-        Comps: ComponentSequence,
-    {
-        self.create_ent(entity_uid, components.into_parts_array());
-    }
-
-    pub fn add_component(&mut self, entity_id: Uid, component_parts: ComponentParts)
-    {
-        Self::add_entity_components(
-            entity_id,
-            [component_parts],
-            &mut self.data.component_storage,
-            &EventSubmitter::new(&self.data.new_events),
-        );
-    }
-
-    pub fn create_declared_entity(&mut self, entity_decl: &EntityDeclaration)
-    {
-        entity_decl.create(self);
-    }
-
-    /// Adds a globally shared singleton value.
-    ///
-    /// # Errors
-    /// Returns `Err` if this [`Sole`] has already been added.
-    pub fn add_sole<SoleT>(&mut self, sole: SoleT) -> Result<(), SoleAlreadyExistsError>
-    where
-        SoleT: Sole,
-    {
-        self.data.sole_storage.insert(sole)
-    }
-
-    pub fn register_observer<'this, SystemImpl, ObserverT>(
-        &'this mut self,
-        observer: ObserverT,
-    ) where
-        ObserverT: Observer<'this, SystemImpl>,
-    {
-        let (wrapper_comp, mut system_callbacks) = observer.finish_observer();
-
-        let ent_id = Uid::new_unique(UidKind::Entity);
-
-        self.create_ent(
-            ent_id,
-            [wrapper_comp.into_parts()].into_iter().chain(
-                ObserverT::observed_events()
-                    .into_iter()
-                    .map(IntoComponentParts::into_parts),
-            ),
-        );
-
-        system_callbacks.on_created(self, SystemMetadata { ent_id });
-    }
-
-    pub fn register_system<'this, SystemImpl>(
-        &'this mut self,
-        phase_euid: Uid,
-        system: impl System<'this, SystemImpl>,
-    )
-    {
-        let (type_erased_system, mut system_callbacks) = system.finish();
-
-        let system_ent_id =
-            self.create_entity((SystemComponent { system: type_erased_system },));
-
-        system_callbacks.on_created(self, SystemMetadata { ent_id: system_ent_id });
-
-        self.create_entity_with_uid(
-            phase_euid,
-            (Pair::builder()
-                .relation::<PhaseHasSystem>()
-                .target_id(system_ent_id)
-                .build(),),
-        );
-    }
-
-    /// Adds a extensions.
-    pub fn add_extension(&mut self, extension: impl Extension)
-    {
-        let extension_collector = ExtensionCollector::new(self);
-
-        extension.collect(extension_collector);
-    }
-
-    pub fn query<FieldTerms, FieldlessTerms>(
-        &self,
-    ) -> Query<'_, FieldTerms, FieldlessTerms>
-    where
-        FieldTerms: QueryTermWithFieldTuple,
-        FieldlessTerms: QueryTermWithoutFieldTuple,
-    {
-        Query::new(self)
-    }
-
-    pub fn flexible_query<const MAX_TERM_CNT: usize>(
-        &self,
-        terms: QueryTerms<MAX_TERM_CNT>,
-    ) -> FlexibleQuery<'_, MAX_TERM_CNT>
-    {
-        FlexibleQuery::new(self, terms)
-    }
-
-    pub fn get_entity(&self, entity_id: Uid) -> Option<EntityHandle<'_>>
-    {
-        let archetype = self
-            .data
-            .component_storage
-            .get_entity_archetype(entity_id)?;
-
-        let Some(entity) = archetype.get_entity_by_id(entity_id) else {
-            unreachable!("Should exist since archetype was found by entity id");
-        };
-
-        Some(EntityHandle::new(archetype, entity, self))
-    }
-
-    pub fn get_sole<SoleT: Sole>(&self) -> Option<Single<'_, SoleT>>
-    {
-        Some(Single::new(self.data.sole_storage.get::<SoleT>()?))
-    }
-
-    pub fn event_submitter(&self) -> EventSubmitter<'_>
-    {
-        EventSubmitter::new(&self.data.new_events)
-    }
-
-    /// Performs a single tick.
-    /// # Panics
-    /// Will panic if mutable internal lock cannot be acquired.
-    pub fn step(&mut self) -> StepResult
-    {
-        if self.stop.load(Ordering::Relaxed) {
-            return StepResult::Stop;
-        }
-
-        if self
-            .is_first_tick
-            .compare_exchange(false, true, Ordering::Relaxed, Ordering::Relaxed)
-            .is_ok()
-        {
-            let Some(start_phase_entity) = self.get_entity(*START_PHASE) else {
-                unreachable!();
-            };
-
-            self.run_phase_systems(&start_phase_entity);
-        }
-
-        self.perform_phases();
-
-        self.emit_new_events();
-
-        self.data.component_storage.create_imaginary_archetypes();
-
-        self.perform_queued_actions();
-
-        if self.stop.load(Ordering::Relaxed) {
-            return StepResult::Stop;
-        }
-
-        let Some(mut stats) = self.get_sole::<Stats>() else {
-            unreachable!(); // Reason: is added in World::new
-        };
-
-        stats.current_tick += 1;
-
-        StepResult::Continue
-    }
-
-    /// Starts a loop which calls [`Self::step`] until the world is stopped.
-    pub fn start_loop(&mut self)
-    {
-        while let StepResult::Continue = self.step() {}
-    }
-
-    #[cfg(feature = "vizoxide")]
-    pub fn create_vizoxide_archetype_graph(
-        &self,
-        name: impl AsRef<str>,
-    ) -> Result<vizoxide::Graph, vizoxide::GraphvizError>
-    {
-        use std::borrow::Cow;
-
-        use crate::component::storage::{
-            VizoxideArchetypeGraphEdgeKind,
-            VizoxideArchetypeGraphParams,
-        };
-
-        self.data.component_storage.create_vizoxide_archetype_graph(
-            name,
-            VizoxideArchetypeGraphParams {
-                create_node_name: |archetype, _| {
-                    Cow::Owned(format!(
-                        "[{}]",
-                        archetype
-                            .component_ids_sorted()
-                            .into_iter()
-                            .map(|comp_id| comp_id.to_string())
-                            .collect::<Vec<_>>()
-                            .join(", ")
-                    ))
-                },
-                create_node_cb: |_archetype, archetype_metadata, node_builder| {
-                    if archetype_metadata.is_imaginary {
-                        return node_builder.attribute("shape", "ellipse");
-                    }
-
-                    node_builder.attribute("shape", "box")
-                },
-                create_edge_cb: |_, _, edge_kind, edge_builder| {
-                    edge_builder.attribute(
-                        "color",
-                        match edge_kind {
-                            VizoxideArchetypeGraphEdgeKind::Add => "green",
-                            VizoxideArchetypeGraphEdgeKind::Remove => "red",
-                        },
-                    )
-                },
-            },
-        )
-    }
-
-    #[tracing::instrument(skip_all)]
-    fn create_ent(
-        &mut self,
-        entity_uid: Uid,
-        components: impl IntoIterator<Item = ComponentParts>,
-    )
-    {
-        debug_assert_eq!(entity_uid.kind(), UidKind::Entity);
-
-        if let Err(EntityAlreadyExistsError) =
-            self.data.component_storage.create_entity(entity_uid)
-        {
-            // This is fine
-        }
-
-        Self::add_entity_components(
-            entity_uid,
-            components,
-            &mut self.data.component_storage,
-            &EventSubmitter::new(&self.data.new_events),
-        );
-    }
-
-    fn run_phase_systems(&self, phase_entity: &EntityHandle<'_>)
-    {
-        // The phase's systems are retrieved this way so that the order they are
-        // run is the same order as they were registered, even if they have local
-        // components.
-        for system_entity in phase_entity
-            .get_wildcard_pair_matches::<PhaseHasSystem, Wildcard>()
-            .into_iter()
-            .filter_map(|phase_has_system| phase_has_system.get_target_ent())
-        {
-            let Some(system) = system_entity.get::<SystemComponent>() else {
-                cold_path();
-                continue;
-            };
-
-            // SAFETY: The world lives long enough
-            if let Err(err) = unsafe {
-                system
-                    .system
-                    .run(self, SystemMetadata { ent_id: system_entity.uid() })
-            } {
-                cold_path();
-
-                (self.error_handler)(
-                    err,
-                    ErrorMetadata {
-                        source_name: system.system.name(),
-                        source_kind: ErrorSourceKind::System,
-                    },
-                )
-            }
-        }
-    }
-
-    fn perform_child_phases(&self, parent_phase_euid: Uid)
-    {
-        let phase_query = self.flexible_query(
-            QueryTerms::<2>::builder()
-                .with_required([
-                    Phase::id(),
-                    Pair::builder()
-                        .relation::<ChildOf>()
-                        .target_id(parent_phase_euid)
-                        .build()
-                        .id(),
-                ])
-                .build(),
-        );
-
-        for child_phase_entity in &phase_query {
-            self.run_phase_systems(&child_phase_entity);
-            self.perform_child_phases(child_phase_entity.uid());
-        }
-    }
-
-    fn perform_single_phase(&self, phase_entity_id: Uid)
-    {
-        let Some(phase_entity) = self.get_entity(phase_entity_id) else {
-            unreachable!();
-        };
-
-        self.run_phase_systems(&phase_entity);
-        self.perform_child_phases(phase_entity_id);
-    }
-
-    fn perform_phases(&self)
-    {
-        self.perform_single_phase(*PRE_UPDATE_PHASE);
-        self.perform_single_phase(*UPDATE_PHASE);
-        self.perform_single_phase(*POST_UPDATE_PHASE);
-    }
-
-    fn emit_new_events(&self)
-    {
-        loop {
-            let new_events = {
-                let mut new_events_lock = self
-                    .data
-                    .new_events
-                    .write_nonblock()
-                    .expect("Failed to acquire read-write lock to new events");
-
-                if new_events_lock.is_empty() {
-                    break;
-                }
-
-                new_events_lock.take()
-            };
-
-            for (event_id, event_matches) in new_events {
-                self.emit_event_observers(
-                    event_id,
-                    &EmittedEvent {
-                        event: event_id,
-                        match_ids: &event_matches.match_ids,
-                    },
-                );
-            }
-        }
-    }
-
-    #[tracing::instrument(skip_all)]
-    fn perform_queued_actions(&mut self)
-    {
-        let mut action_queue_lock = self
-            .data
-            .action_queue
-            .queue
-            .write_nonblock()
-            .unwrap_or_else(|err| {
-                panic!("Failed to take read-write action queue lock: {err}",);
-            });
-
-        for action in action_queue_lock.drain(..) {
-            match action {
-                Action::Spawn(new_entity_uid, components) => {
-                    if let Err(err) =
-                        self.data.component_storage.create_entity(new_entity_uid)
-                    {
-                        tracing::warn!("Failed to create entity: {err}");
-                        continue;
-                    }
-
-                    Self::add_entity_components(
-                        new_entity_uid,
-                        components,
-                        &mut self.data.component_storage,
-                        &EventSubmitter::new(&self.data.new_events),
-                    );
-                }
-                Action::Despawn(entity_uid) => {
-                    if let Err(err) =
-                        self.data.component_storage.remove_entity(entity_uid)
-                    {
-                        tracing::error!("Failed to despawn entity: {err}");
-                    }
-                }
-                Action::AddComponents(entity_uid, components) => {
-                    Self::add_entity_components(
-                        entity_uid,
-                        components,
-                        &mut self.data.component_storage,
-                        &EventSubmitter::new(&self.data.new_events),
-                    );
-                }
-                Action::RemoveComponents(entity_uid, component_ids) => {
-                    Self::remove_entity_components(
-                        entity_uid,
-                        component_ids,
-                        &mut self.data.component_storage,
-                    );
-                }
-                Action::Stop => {
-                    self.stop.store(true, Ordering::Relaxed);
-                }
-            }
-        }
-    }
-
-    fn add_entity_components(
-        entity_uid: Uid,
-        components: impl IntoIterator<Item = ComponentParts>,
-        component_storage: &mut ComponentStorage,
-        event_submitter: &EventSubmitter<'_>,
-    )
-    {
-        let component_iter = components.into_iter();
-
-        for component_parts in component_iter {
-            let comp_id = component_parts.id();
-
-            let comp_name = component_parts.name();
-
-            if let Err(err) = component_storage.add_entity_component(
-                entity_uid,
-                (comp_id, comp_name, component_parts.into_data()),
-            ) {
-                tracing::error!("Failed to add component {comp_name} to entity: {err}");
-                continue;
-            }
-
-            if comp_id.kind() == UidKind::Pair {
-                continue;
-            }
-
-            event_submitter.submit_event(
-                &Pair::builder()
-                    .relation::<Added>()
-                    .target_id(comp_id)
-                    .build(),
-                entity_uid,
-            );
-        }
-    }
-
-    fn remove_entity_components(
-        entity_uid: Uid,
-        component_ids: impl IntoIterator<Item = Uid>,
-        component_storage: &mut ComponentStorage,
-    )
-    {
-        let component_id_iter = component_ids.into_iter();
-
-        for component_id in component_id_iter {
-            if let Err(err) =
-                component_storage.remove_entity_component(entity_uid, component_id)
-            {
-                tracing::error!("Failed to remove component to entity: {err}");
-            }
-        }
-    }
-
-    fn emit_event_observers(&self, event_id: Uid, emitted_event: &EmittedEvent<'_>)
-    {
-        assert_eq!(event_id.kind(), UidKind::Pair);
-
-        let query = Query::<(&ObserverWrapperComponent,)>::from_flexible_query(
-            self.flexible_query(
-                QueryTerms::<QUERY_MAX_TERM_CNT>::builder()
-                    .with_required([ObserverWrapperComponent::id(), event_id])
-                    .build(),
-            ),
-        );
-
-        for (observer_ent_id, (observer,)) in query.iter_with_euids() {
-            if let Err(err) = unsafe {
-                observer.run(
-                    self,
-                    SystemMetadata { ent_id: observer_ent_id },
-                    emitted_event.clone(),
-                )
-            } {
-                cold_path();
-
-                (self.error_handler)(
-                    err,
-                    ErrorMetadata {
-                        source_name: observer.name(),
-                        source_kind: ErrorSourceKind::Observer,
-                    },
-                )
-            }
-        }
-    }
-}
-
-impl Default for World
-{
-    fn default() -> Self
-    {
-        Self::new()
-    }
-}
-
-/// The result of calling [`World::step`].
-pub enum StepResult
-{
-    /// Another step can be made.
-    Continue,
-
-    /// The world have been stopped so no step can be made again.
-    Stop,
-}
-
-#[derive(Debug, Default)]
-struct WorldData
-{
-    component_storage: ComponentStorage,
-    sole_storage: SoleStorage,
-    action_queue: Rc<ActionQueue>,
-    new_events: Lock<NewEvents>,
-}
-
-#[derive(Debug, Clone)]
-pub struct EntityComponentRef<'a>
-{
-    component_id: Uid,
-    component: &'a ArchetypeEntityComponent,
-    entity_id: Uid,
-}
-
-impl<'a> EntityComponentRef<'a>
-{
-    fn component(&self) -> &'a Lock<Box<dyn Any>>
-    {
-        self.component.component()
-    }
-
-    #[must_use]
-    pub fn id(&self) -> Uid
-    {
-        self.component_id
-    }
-
-    #[must_use]
-    pub fn entity_id(&self) -> Uid
-    {
-        self.entity_id
-    }
-
-    fn new(component_id: Uid, comp: &'a ArchetypeEntityComponent, entity_id: Uid)
-    -> Self
-    {
-        Self {
-            component_id,
-            component: comp,
-            entity_id,
-        }
-    }
-}
-
-#[derive(Debug, Default)]
-struct ActionQueue
-{
-    queue: Lock<Vec<Action>>,
-}
-
-impl ActionQueue
-{
-    fn push(&self, action: Action)
-    {
-        self.queue
-            .write_nonblock()
-            .expect("Failed to aquire read-write lock to action queue")
-            .push(action);
-    }
-}
-
-#[derive(Debug, thiserror::Error)]
-#[error("Sole {0} already exists")]
-pub struct SoleAlreadyExistsError(pub &'static str);
-
-#[derive(Debug)]
-struct StoredSole
-{
-    sole: Arc<Lock<Box<dyn Sole>>>,
-    drop_last: bool,
-}
-
-#[derive(Debug, Default)]
-struct SoleStorage
-{
-    storage: HashMap<TypeId, ManuallyDrop<StoredSole>>,
-}
-
-impl SoleStorage
-{
-    fn get<SoleT: Sole>(&self) -> Option<&Arc<Lock<Box<dyn Sole>>>>
-    {
-        self.storage
-            .get(&TypeId::of::<SoleT>())
-            .map(|sole| &sole.sole)
-    }
-
-    fn insert<SoleT: Sole>(&mut self, sole: SoleT) -> Result<(), SoleAlreadyExistsError>
-    {
-        let sole_type_id = TypeId::of::<SoleT>();
-
-        if self.storage.contains_key(&sole_type_id) {
-            return Err(SoleAlreadyExistsError(type_name::<SoleT>()));
-        }
-
-        let drop_last = sole.drop_last();
-
-        // TODO: Reconsider this maybe?
-        #[allow(clippy::arc_with_non_send_sync)]
-        self.storage.insert(
-            sole_type_id,
-            ManuallyDrop::new(StoredSole {
-                sole: Arc::new(Lock::new(Box::new(sole), type_name::<SoleT>())),
-                drop_last,
-            }),
-        );
-
-        Ok(())
-    }
-}
-
-impl Drop for SoleStorage
-{
-    fn drop(&mut self)
-    {
-        let mut soles_to_drop_last = Vec::new();
-
-        for sole in self.storage.values_mut() {
-            if sole.drop_last {
-                soles_to_drop_last.push(sole);
-                continue;
-            }
-
-            unsafe {
-                ManuallyDrop::drop(sole);
-            }
-        }
-
-        for sole in &mut soles_to_drop_last {
-            unsafe {
-                ManuallyDrop::drop(sole);
-            }
-        }
-    }
-}
diff --git a/ecs/src/lock.rs b/ecs/src/lock.rs
deleted file mode 100644
index fe4e08b..0000000
--- a/ecs/src/lock.rs
+++ /dev/null
@@ -1,259 +0,0 @@
-use std::any::type_name;
-use std::mem::forget;
-use std::ops::{Deref, DerefMut};
-
-use parking_lot::{
-    MappedRwLockReadGuard,
-    MappedRwLockWriteGuard,
-    RwLock,
-    RwLockReadGuard,
-    RwLockWriteGuard,
-};
-
-#[derive(Debug)]
-pub struct Lock<Value>
-{
-    inner: RwLock<Value>,
-    value_type_name: &'static str,
-}
-
-impl<Value> Lock<Value>
-{
-    pub fn new(value: Value, value_type_name: &'static str) -> Self
-    {
-        Self {
-            inner: RwLock::new(value),
-            value_type_name,
-        }
-    }
-
-    /// Tries to a acquire a handle to the resource with read access.
-    ///
-    /// # Errors
-    /// Returns `Err` if unavailable (A mutable handle is hold).
-    pub fn read_nonblock(&self) -> Result<ReadGuard<'_, Value>, Error>
-    {
-        let guard = self.inner.try_read().ok_or(Error::ReadUnavailable)?;
-
-        tracing::trace!("Acquired lock to value of type {}", self.value_type_name);
-
-        Ok(ReadGuard {
-            inner: guard,
-            value_type_name: self.value_type_name,
-        })
-    }
-
-    /// Tries to a acquire a handle to the resource with mutable access.
-    ///
-    /// # Errors
-    /// Returns `Err` if unavailable (A mutable or immutable handle is hold).
-    pub fn write_nonblock(&self) -> Result<WriteGuard<'_, Value>, Error>
-    {
-        let guard = self.inner.try_write().ok_or(Error::WriteUnavailable)?;
-
-        tracing::trace!(
-            "Acquired mutable lock to value of type {}",
-            self.value_type_name
-        );
-
-        Ok(WriteGuard {
-            inner: guard,
-            value_type_name: self.value_type_name,
-        })
-    }
-}
-
-impl<Value: Default + 'static> Default for Lock<Value>
-{
-    fn default() -> Self
-    {
-        Self::new(Value::default(), type_name::<Value>())
-    }
-}
-
-#[derive(Debug, thiserror::Error)]
-pub enum Error
-{
-    #[error("Lock is unavailable for reading")]
-    ReadUnavailable,
-
-    #[error("Lock is unavailable for writing")]
-    WriteUnavailable,
-}
-
-#[derive(Debug)]
-pub struct ReadGuard<'guard, Value>
-{
-    inner: RwLockReadGuard<'guard, Value>,
-    value_type_name: &'static str,
-}
-
-impl<'guard, Value> ReadGuard<'guard, Value>
-{
-    pub fn try_map<NewValue>(
-        this: Self,
-        func: impl FnOnce(&Value) -> Option<&NewValue>,
-    ) -> Result<MappedReadGuard<'guard, NewValue>, Self>
-    {
-        let value_type_name = this.value_type_name;
-
-        // The 'inner' field cannot be moved out of ReadGuard in a normal way since
-        // ReadGuard implements Drop
-        let inner = unsafe { std::ptr::read(&raw const this.inner) };
-        forget(this);
-
-        match RwLockReadGuard::try_map(inner, func) {
-            Ok(mapped_guard) => {
-                Ok(MappedReadGuard { inner: mapped_guard, value_type_name })
-            }
-            Err(unmapped_guard) => Err(Self {
-                inner: unmapped_guard,
-                value_type_name,
-            }),
-        }
-    }
-}
-
-impl<Value> Deref for ReadGuard<'_, Value>
-{
-    type Target = Value;
-
-    fn deref(&self) -> &Self::Target
-    {
-        &self.inner
-    }
-}
-
-impl<Value> Drop for ReadGuard<'_, Value>
-{
-    fn drop(&mut self)
-    {
-        tracing::trace!("Dropped lock to value of type {}", self.value_type_name);
-    }
-}
-
-#[derive(Debug)]
-pub struct MappedReadGuard<'guard, Value>
-{
-    inner: MappedRwLockReadGuard<'guard, Value>,
-    value_type_name: &'static str,
-}
-
-impl<Value> Deref for MappedReadGuard<'_, Value>
-{
-    type Target = Value;
-
-    fn deref(&self) -> &Self::Target
-    {
-        &self.inner
-    }
-}
-
-impl<Value> Drop for MappedReadGuard<'_, Value>
-{
-    fn drop(&mut self)
-    {
-        tracing::trace!(
-            "Dropped mapped lock to value of type {}",
-            self.value_type_name
-        );
-    }
-}
-
-#[derive(Debug)]
-pub struct WriteGuard<'guard, Value>
-{
-    inner: RwLockWriteGuard<'guard, Value>,
-    value_type_name: &'static str,
-}
-
-impl<'guard, Value> WriteGuard<'guard, Value>
-{
-    pub fn try_map<NewValue>(
-        this: Self,
-        func: impl FnOnce(&mut Value) -> Option<&mut NewValue>,
-    ) -> Result<MappedWriteGuard<'guard, NewValue>, Self>
-    {
-        let value_type_name = this.value_type_name;
-
-        // The 'inner' field cannot be moved out of ReadGuard in a normal way since
-        // ReadGuard implements Drop
-        let inner = unsafe { std::ptr::read(&raw const this.inner) };
-        forget(this);
-
-        match RwLockWriteGuard::try_map(inner, func) {
-            Ok(mapped_guard) => {
-                Ok(MappedWriteGuard { inner: mapped_guard, value_type_name })
-            }
-            Err(unmapped_guard) => Err(Self {
-                inner: unmapped_guard,
-                value_type_name,
-            }),
-        }
-    }
-}
-
-impl<Value> Deref for WriteGuard<'_, Value>
-{
-    type Target = Value;
-
-    fn deref(&self) -> &Self::Target
-    {
-        &self.inner
-    }
-}
-
-impl<Value> DerefMut for WriteGuard<'_, Value>
-{
-    fn deref_mut(&mut self) -> &mut Self::Target
-    {
-        &mut self.inner
-    }
-}
-
-impl<Value> Drop for WriteGuard<'_, Value>
-{
-    fn drop(&mut self)
-    {
-        tracing::trace!(
-            "Dropped mutable lock to value of type {}",
-            self.value_type_name
-        );
-    }
-}
-
-#[derive(Debug)]
-pub struct MappedWriteGuard<'guard, Value>
-{
-    inner: MappedRwLockWriteGuard<'guard, Value>,
-    value_type_name: &'static str,
-}
-
-impl<Value> Deref for MappedWriteGuard<'_, Value>
-{
-    type Target = Value;
-
-    fn deref(&self) -> &Self::Target
-    {
-        &self.inner
-    }
-}
-
-impl<Value> DerefMut for MappedWriteGuard<'_, Value>
-{
-    fn deref_mut(&mut self) -> &mut Self::Target
-    {
-        &mut self.inner
-    }
-}
-
-impl<Value> Drop for MappedWriteGuard<'_, Value>
-{
-    fn drop(&mut self)
-    {
-        tracing::trace!(
-            "Dropped mapped mutable lock to value of type {}",
-            self.value_type_name
-        );
-    }
-}
diff --git a/ecs/src/pair.rs b/ecs/src/pair.rs
deleted file mode 100644
index 0d353e3..0000000
--- a/ecs/src/pair.rs
+++ /dev/null
@@ -1,687 +0,0 @@
-use std::any::type_name;
-use std::convert::Infallible;
-use std::marker::PhantomData;
-
-use crate::component::{
-    Handle as ComponentHandle,
-    HandleError as ComponentHandleError,
-    HandleMut as ComponentHandleMut,
-    IntoParts as IntoComponentParts,
-    Parts as ComponentParts,
-};
-use crate::entity::{
-    Handle as EntityHandle,
-    MatchingComponentIter as EntityMatchingComponentIter,
-};
-use crate::query::{
-    TermWithField as QueryTermWithField,
-    TermsBuilder as QueryTermsBuilder,
-    TermsBuilderInterface,
-};
-use crate::uid::{Kind as UidKind, PairParams as UidPairParams, Uid, With as WithUid};
-use crate::util::impl_multiple;
-use crate::{Component, EntityComponentRef, World};
-
-/// Pair builder.
-#[derive(Debug)]
-pub struct Builder<Relation, Target>
-{
-    relation: Relation,
-    target: Target,
-}
-
-impl<Relation, Target> Builder<Relation, Target>
-{
-    pub fn relation<NewRelation: Component>(self) -> Builder<Uid, Target>
-    {
-        Builder {
-            relation: NewRelation::id(),
-            target: self.target,
-        }
-    }
-
-    pub fn relation_id(self, id: Uid) -> Builder<Uid, Target>
-    {
-        Builder { relation: id, target: self.target }
-    }
-
-    pub fn target<NewTarget: Component>(self) -> Builder<Relation, Uid>
-    {
-        Builder {
-            relation: self.relation,
-            target: NewTarget::id(),
-        }
-    }
-
-    pub fn target_id(self, id: Uid) -> Builder<Relation, Uid>
-    {
-        Builder { relation: self.relation, target: id }
-    }
-}
-
-impl_multiple!(
-    Builder,
-    (impl<Target> _<><Uid, Target>, impl<Target> _<><(), Target>)
-    cb=(type_params=(ty_param_1, ty_param_2)) => {
-        pub fn target_as_data<NewTarget: Component>(
-            self,
-            data: NewTarget,
-        ) -> Builder<$ty_param_1, NewTarget>
-        {
-            Builder {
-                relation: self.relation,
-                target: data,
-            }
-        }
-    }
-);
-
-impl_multiple!(
-    Builder,
-    (impl<Relation> _<><Relation, Uid>, impl<Relation> _<><Relation, ()>)
-    cb=(type_params=(ty_param_1, ty_param_2)) => {
-        pub fn relation_as_data<NewRelation: Component>(
-            self,
-            data: NewRelation,
-        ) -> Builder<NewRelation, $ty_param_2>
-        {
-            Builder {
-                relation: data,
-                target: self.target,
-            }
-        }
-    }
-);
-
-impl_multiple!(
-    Builder,
-    (
-        impl _<><Uid, Uid>,
-        impl<Relation: Component> _<><Relation, Uid>,
-        impl<Target: Component> _<><Uid, Target>,
-        impl<Relation: Component, Target: Component> _<><Relation, Target>
-    )
-    cb=(type_params=(ty_param_1, ty_param_2)) => {
-        #[must_use]
-        pub fn build(self) -> Pair<$ty_param_1, $ty_param_2>
-        {
-            Pair {
-                relation: self.relation,
-                target: self.target
-            }
-        }
-    }
-);
-
-impl Default for Builder<(), ()>
-{
-    fn default() -> Self
-    {
-        Self { relation: (), target: () }
-    }
-}
-
-#[derive(Debug)]
-pub struct Pair<Relation, Target>
-{
-    relation: Relation,
-    target: Target,
-}
-
-impl Pair<(), ()>
-{
-    #[must_use]
-    pub fn builder() -> Builder<(), ()>
-    {
-        Builder { relation: (), target: () }
-    }
-}
-
-impl Pair<Uid, Uid>
-{
-    #[must_use]
-    pub fn id(&self) -> Uid
-    {
-        Uid::new_pair(&UidPairParams {
-            relation: self.relation,
-            target: self.target,
-        })
-    }
-}
-
-impl IntoComponentParts for Pair<Uid, Uid>
-{
-    fn into_parts(self) -> ComponentParts
-    {
-        ComponentParts::builder().name("Pair").build(self.id(), ())
-    }
-}
-
-impl<Target> IntoComponentParts for Pair<Uid, Target>
-where
-    Target: Component,
-{
-    fn into_parts(self) -> ComponentParts
-    {
-        let id = Uid::new_pair(&UidPairParams {
-            relation: self.relation,
-            target: Target::id(),
-        });
-
-        ComponentParts::builder()
-            .name("Pair")
-            .build(id, self.target)
-    }
-}
-
-impl<Relation> IntoComponentParts for Pair<Relation, Uid>
-where
-    Relation: Component,
-{
-    fn into_parts(self) -> ComponentParts
-    {
-        let id = Uid::new_pair(&UidPairParams {
-            relation: Relation::id(),
-            target: self.target,
-        });
-
-        ComponentParts::builder()
-            .name("Pair")
-            .build(id, self.relation)
-    }
-}
-
-impl<Relation, Target> QueryTermWithField for Pair<Relation, &Target>
-where
-    Relation: Component,
-    Target: Component,
-{
-    type Field<'a> = ComponentHandle<'a, Target>;
-
-    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
-        terms_builder: &mut QueryTermsBuilder<MAX_TERM_CNT>,
-    )
-    {
-        terms_builder.with_required([Pair::<Relation, Target>::uid()]);
-    }
-
-    fn get_field<'world>(
-        entity_handle: &EntityHandle<'world>,
-        _world: &'world World,
-    ) -> Self::Field<'world>
-    {
-        let target_component = entity_handle
-            .get_matching_components(Pair::<Relation, Target>::uid())
-            .next()
-            .expect("Not possible");
-
-        Self::Field::from_entity_component_ref(&target_component).unwrap_or_else(|err| {
-            panic!(
-                "Creating handle to target component {} failed: {err}",
-                type_name::<Target>()
-            );
-        })
-    }
-}
-
-impl<Relation, Target> QueryTermWithField for Pair<Relation, &mut Target>
-where
-    Relation: Component,
-    Target: Component,
-{
-    type Field<'a> = ComponentHandleMut<'a, Target>;
-
-    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
-        terms_builder: &mut QueryTermsBuilder<MAX_TERM_CNT>,
-    )
-    {
-        terms_builder.with_required([Pair::<Relation, Target>::uid()]);
-    }
-
-    fn get_field<'world>(
-        entity_handle: &EntityHandle<'world>,
-        world: &'world World,
-    ) -> Self::Field<'world>
-    {
-        let target_component = entity_handle
-            .get_matching_components(Pair::<Relation, Target>::uid())
-            .next()
-            .expect("Not possible");
-
-        Self::Field::from_entity_component_ref(&target_component, world).unwrap_or_else(
-            |err| {
-                panic!(
-                    "Creating handle to target component {} failed: {err}",
-                    type_name::<Target>()
-                );
-            },
-        )
-    }
-}
-
-// TODO: implement QueryTermWithField for Pair<&Relation, Target> (or equivalent)
-// TODO: implement QueryTermWithField for Pair<&mut Relation, Target> (or equivalent)
-
-impl<Relation> QueryTermWithField for Pair<Relation, Wildcard>
-where
-    Relation: Component,
-{
-    type Field<'a> = WithWildcard<'a, Relation, Wildcard>;
-
-    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
-        terms_builder: &mut QueryTermsBuilder<MAX_TERM_CNT>,
-    )
-    {
-        terms_builder.with_required([Self::uid()]);
-    }
-
-    fn get_field<'world>(
-        entity_handle: &EntityHandle<'world>,
-        world: &'world World,
-    ) -> Self::Field<'world>
-    {
-        let first_matching_comp = entity_handle
-            .get_matching_components(Self::uid())
-            .next()
-            .expect("Not possible");
-
-        WithWildcard {
-            world,
-            component_ref: first_matching_comp,
-            _pd: PhantomData,
-        }
-    }
-}
-
-impl<Relation, Target> WithUid for Pair<Relation, Target>
-where
-    Relation: Component,
-    Target: Component,
-{
-    fn uid() -> Uid
-    {
-        Uid::new_pair(&UidPairParams {
-            relation: Relation::id(),
-            target: Target::id(),
-        })
-    }
-}
-
-impl<Relation> WithUid for Pair<Relation, Wildcard>
-where
-    Relation: Component,
-{
-    fn uid() -> Uid
-    {
-        Uid::new_pair(&UidPairParams {
-            relation: Relation::id(),
-            target: Wildcard::uid(),
-        })
-    }
-}
-
-impl<Relation> QueryTermWithField for &'_ [Pair<Relation, Wildcard>]
-where
-    Relation: Component,
-{
-    type Field<'a> = MultipleWithWildcard<'a, Relation, Wildcard>;
-
-    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
-        _terms_builder: &mut QueryTermsBuilder<MAX_TERM_CNT>,
-    )
-    {
-    }
-
-    fn get_field<'world>(
-        entity_handle: &EntityHandle<'world>,
-        world: &'world World,
-    ) -> Self::Field<'world>
-    {
-        MultipleWithWildcard {
-            entity_handle: entity_handle.clone(),
-            world,
-            _pd: PhantomData,
-        }
-    }
-}
-
-/// Reference to a pair with a wildcard relation/target.
-#[derive(Debug)]
-pub struct WithWildcard<'world, Relation, Target>
-{
-    world: &'world World,
-    component_ref: EntityComponentRef<'world>,
-    _pd: PhantomData<(Relation, Target)>,
-}
-
-impl<'world, Relation, Target> WithWildcard<'world, Relation, Target>
-{
-    /// Returns a new `WithWildcard`.
-    ///
-    /// # Panics
-    /// This function will panic if:
-    /// - The given component's ID is not a pair ID.
-    /// - `Relation::uid()` is not wildcard and does not equal to the relation of the
-    ///   given component's ID
-    /// - `Target::uid()` is not wildcard and does not equal to the target of the given
-    ///   component's ID
-    /// - Both `Relation::uid()` and `Target::uid()` are wildcards
-    /// - Neither `Relation::uid()` or `Target::uid()` are wildcards
-    pub fn new(world: &'world World, component_ref: EntityComponentRef<'world>) -> Self
-    where
-        Relation: ComponentOrWildcard,
-        Target: ComponentOrWildcard,
-    {
-        let component_id = component_ref.id();
-
-        assert!(component_id.kind() == UidKind::Pair);
-
-        assert!(
-            Relation::uid() == Wildcard::uid()
-                || component_id.relation_component() == Relation::uid()
-        );
-
-        assert!(
-            Target::uid() == Wildcard::uid()
-                || component_id.target_component() == Target::uid()
-        );
-
-        assert!(Relation::uid() == Wildcard::uid() || Target::uid() == Wildcard::uid());
-
-        assert!(
-            !(Relation::uid() == Wildcard::uid() && Target::uid() == Wildcard::uid())
-        );
-
-        WithWildcard {
-            world,
-            component_ref,
-            _pd: PhantomData,
-        }
-    }
-
-    /// Returns the [`Uid`] of the pair.
-    #[must_use]
-    pub fn id(&self) -> Uid
-    {
-        self.component_ref.id()
-    }
-
-    /// Attempts to get the component data of this pair, returning `None` if the `Data`
-    /// type is incorrect.
-    ///
-    /// # Panics
-    /// Will panic if the component data is mutably borrowed elsewhere.
-    #[must_use]
-    pub fn get_data<Data>(&self) -> Option<ComponentHandle<'_, Data>>
-    where
-        Data: 'static,
-    {
-        ComponentHandle::<Data>::from_entity_component_ref(&self.component_ref)
-            .map_or_else(
-                |err| match err {
-                    ComponentHandleError::IncorrectType => None,
-                    err @ ComponentHandleError::AcquireLockFailed(_) => {
-                        panic!(
-                            "Creating handle to pair data as component {} failed: {err}",
-                            type_name::<Data>()
-                        );
-                    }
-                },
-                Some,
-            )
-    }
-
-    /// Attempts to get the component data of this pair, returning `None` if the `Data`
-    /// type is incorrect.
-    ///
-    /// # Panics
-    /// Will panic if the component data is borrowed elsewhere.
-    #[must_use]
-    pub fn get_data_mut<Data>(&self) -> Option<ComponentHandleMut<'_, Data>>
-    where
-        Data: 'static,
-    {
-        ComponentHandleMut::<Data>::from_entity_component_ref(
-            &self.component_ref,
-            self.world,
-        )
-        .map_or_else(
-            |err| match err {
-                ComponentHandleError::IncorrectType => None,
-                err @ ComponentHandleError::AcquireLockFailed(_) => {
-                    panic!(
-                        "Creating handle to pair data as component {} failed: {err}",
-                        type_name::<Data>()
-                    );
-                }
-            },
-            Some,
-        )
-    }
-}
-
-impl<'world, Relation> WithWildcard<'world, Relation, Wildcard>
-where
-    Relation: Component,
-{
-    /// Attempts to retrieve the target as a entity, returning `None` if not found.
-    #[must_use]
-    pub fn get_target_ent(&self) -> Option<EntityHandle<'world>>
-    {
-        let archetype = self
-            .world
-            .data
-            .component_storage
-            .get_entity_archetype(self.component_ref.id().target_entity())?;
-
-        let Some(archetype_entity) =
-            archetype.get_entity_by_id(self.component_ref.id().target_entity())
-        else {
-            unreachable!();
-        };
-
-        Some(EntityHandle::new(archetype, archetype_entity, self.world))
-    }
-
-    /// Attempts to get the component data of this pair, returning `None` if the
-    /// `Relation` type is incorrect.
-    ///
-    /// # Panics
-    /// Will panic if the component data is mutably borrowed elsewhere.
-    #[must_use]
-    pub fn get_data_as_relation(&self) -> Option<ComponentHandle<'_, Relation>>
-    {
-        ComponentHandle::<Relation>::from_entity_component_ref(&self.component_ref)
-            .map_or_else(
-                |err| match err {
-                    ComponentHandleError::IncorrectType => None,
-                    err @ ComponentHandleError::AcquireLockFailed(_) => {
-                        panic!(
-                            "Creating handle to pair data as component {} failed: {err}",
-                            type_name::<Relation>()
-                        );
-                    }
-                },
-                Some,
-            )
-    }
-
-    /// Attempts to get the component data of this pair, returning `None` if the
-    /// `Relation` type is incorrect.
-    ///
-    /// # Panics
-    /// Will panic if the component data is borrowed elsewhere.
-    #[must_use]
-    pub fn get_data_as_relation_mut(&self) -> Option<ComponentHandleMut<'_, Relation>>
-    {
-        ComponentHandleMut::<Relation>::from_entity_component_ref(
-            &self.component_ref,
-            self.world,
-        )
-        .map_or_else(
-            |err| match err {
-                ComponentHandleError::IncorrectType => None,
-                err @ ComponentHandleError::AcquireLockFailed(_) => {
-                    panic!(
-                        "Creating handle to pair data as component {} failed: {err}",
-                        type_name::<Relation>()
-                    );
-                }
-            },
-            Some,
-        )
-    }
-}
-
-/// Used to access matching pairs in a entity containing zero or more matching pairs.
-#[derive(Debug)]
-pub struct MultipleWithWildcard<'a, Relation, Target>
-{
-    entity_handle: EntityHandle<'a>,
-    world: &'a World,
-    _pd: PhantomData<(Relation, Target)>,
-}
-
-impl<'world, Relation, Target> MultipleWithWildcard<'world, Relation, Target>
-{
-    /// Returns a new `MultipleWithWildcard`.
-    ///
-    /// # Panics
-    /// This function will panic if:
-    /// - Both `Relation::uid()` and `Target::uid()` are wildcards
-    /// - Neither `Relation::uid()` or `Target::uid()` are wildcards
-    pub fn new(world: &'world World, entity_handle: EntityHandle<'world>) -> Self
-    where
-        Relation: ComponentOrWildcard,
-        Target: ComponentOrWildcard,
-    {
-        assert!(Relation::uid() == Wildcard::uid() || Target::uid() == Wildcard::uid());
-
-        assert!(
-            !(Relation::uid() == Wildcard::uid() && Target::uid() == Wildcard::uid())
-        );
-
-        MultipleWithWildcard {
-            entity_handle,
-            world,
-            _pd: PhantomData,
-        }
-    }
-}
-
-impl<'a, Relation: Component> MultipleWithWildcard<'a, Relation, Wildcard>
-{
-    #[must_use]
-    pub fn get_with_target_id(
-        &self,
-        target_id: Uid,
-    ) -> Option<WithWildcard<'a, Relation, Wildcard>>
-    {
-        Some(WithWildcard {
-            world: self.world,
-            component_ref: self
-                .entity_handle
-                .get_matching_components(
-                    Pair::builder()
-                        .relation::<Relation>()
-                        .target_id(target_id)
-                        .build()
-                        .id(),
-                )
-                .next()?,
-            _pd: PhantomData,
-        })
-    }
-}
-
-impl<'a, Relation: Component> IntoIterator
-    for MultipleWithWildcard<'a, Relation, Wildcard>
-{
-    type IntoIter = WithWildcardIter<'a, Relation, Wildcard>;
-    type Item = <Self::IntoIter as Iterator>::Item;
-
-    fn into_iter(self) -> Self::IntoIter
-    {
-        WithWildcardIter {
-            inner: self
-                .entity_handle
-                .get_matching_components(Pair::<Relation, Wildcard>::uid()),
-            world: self.world,
-            _pd: PhantomData,
-        }
-    }
-}
-
-/// Iterator of matching pairs in a entity.
-pub struct WithWildcardIter<'a, Relation, Target>
-{
-    inner: EntityMatchingComponentIter<'a>,
-    world: &'a World,
-    _pd: PhantomData<(Relation, Target)>,
-}
-
-impl<'a, Relation, Target> Iterator for WithWildcardIter<'a, Relation, Target>
-{
-    type Item = WithWildcard<'a, Relation, Target>;
-
-    fn next(&mut self) -> Option<Self::Item>
-    {
-        let matching_comp = self.inner.next()?;
-
-        Some(WithWildcard {
-            world: self.world,
-            component_ref: matching_comp,
-            _pd: PhantomData,
-        })
-    }
-}
-
-/// Relation denoting a dependency to another entity
-#[derive(Debug, Default, Clone, Copy, Component)]
-pub struct DependsOn;
-
-/// Relation denoting being the child of another entity.
-#[derive(Debug, Default, Clone, Copy, Component)]
-pub struct ChildOf;
-
-#[derive(Debug)]
-pub struct Wildcard(Infallible);
-
-impl Wildcard
-{
-    #[must_use]
-    pub fn uid() -> Uid
-    {
-        Uid::wildcard()
-    }
-}
-
-pub trait ComponentOrWildcard: sealed::Sealed
-{
-    fn uid() -> Uid;
-}
-
-impl<ComponentT: Component> ComponentOrWildcard for ComponentT
-{
-    fn uid() -> Uid
-    {
-        ComponentT::id()
-    }
-}
-
-impl<ComponentT: Component> sealed::Sealed for ComponentT {}
-
-impl ComponentOrWildcard for Wildcard
-{
-    fn uid() -> Uid
-    {
-        Wildcard::uid()
-    }
-}
-
-impl sealed::Sealed for Wildcard {}
-
-mod sealed
-{
-    pub trait Sealed {}
-}
diff --git a/ecs/src/phase.rs b/ecs/src/phase.rs
deleted file mode 100644
index e8d9b71..0000000
--- a/ecs/src/phase.rs
+++ /dev/null
@@ -1,22 +0,0 @@
-use ecs_macros::Component;
-
-use crate::{World, declare_entity};
-
-#[derive(Debug, Default, Clone, Copy, Component)]
-pub struct Phase;
-
-declare_entity!(pub START, (Phase,));
-declare_entity!(pub PRE_UPDATE, (Phase,));
-declare_entity!(pub UPDATE, (Phase,));
-declare_entity!(pub POST_UPDATE, (Phase,));
-
-pub(crate) fn spawn_entities(world: &mut World)
-{
-    world.create_declared_entity(&START);
-    world.create_declared_entity(&PRE_UPDATE);
-    world.create_declared_entity(&UPDATE);
-    world.create_declared_entity(&POST_UPDATE);
-}
-
-#[derive(Debug, Component)]
-pub(crate) struct HasSystem;
diff --git a/ecs/src/query.rs b/ecs/src/query.rs
deleted file mode 100644
index 5f13579..0000000
--- a/ecs/src/query.rs
+++ /dev/null
@@ -1,569 +0,0 @@
-use std::any::type_name;
-use std::marker::PhantomData;
-
-use seq_macro::seq;
-
-use crate::component::{
-    Component,
-    Handle as ComponentHandle,
-    HandleMut as ComponentHandleMut,
-};
-use crate::entity::Handle as EntityHandle;
-use crate::query::flexible::{Iter as FlexibleQueryIter, Query as FlexibleQuery};
-use crate::system::{Metadata as SystemMetadata, Param as SystemParam};
-use crate::uid::{Kind as UidKind, Uid, With as WithUid};
-use crate::util::array_vec::ArrayVec;
-use crate::util::Array;
-use crate::World;
-
-pub mod flexible;
-pub mod term;
-
-// A term tuple type can have a maximum of 17 elements
-pub const MAX_TERM_CNT: usize = 17;
-
-#[derive(Debug)]
-pub struct Query<'world, FieldTerms, FieldlessTerms = ()>
-where
-    FieldTerms: TermWithFieldTuple,
-    FieldlessTerms: TermWithoutFieldTuple,
-{
-    inner: FlexibleQuery<'world, MAX_TERM_CNT>,
-    _pd: PhantomData<(FieldTerms, FieldlessTerms)>,
-}
-
-impl<'world, FieldTerms, FieldlessTerms> Query<'world, FieldTerms, FieldlessTerms>
-where
-    FieldTerms: TermWithFieldTuple,
-    FieldlessTerms: TermWithoutFieldTuple,
-{
-    /// Iterates over the entities matching this query, the iterator item being the entity
-    /// components.
-    #[must_use]
-    pub fn iter<'query>(
-        &'query self,
-    ) -> Iter<'query, 'world, FieldTerms, FlexibleQueryIter<'query>>
-    {
-        tracing::trace!("Searching for {}", std::any::type_name::<FieldTerms>());
-
-        Iter {
-            world: self.inner.world(),
-            inner: self.inner.iter(),
-            comps_pd: PhantomData,
-        }
-    }
-
-    /// Iterates over the entities matching this query, the iterator item being the entity
-    /// [`Uid`] and the matching entity components.
-    #[must_use]
-    pub fn iter_with_euids<'query>(
-        &'query self,
-    ) -> ComponentAndEuidIter<'query, 'world, FieldTerms, FlexibleQueryIter<'query>>
-    {
-        tracing::trace!("Searching for {}", std::any::type_name::<FieldTerms>());
-
-        ComponentAndEuidIter {
-            world: self.inner.world(),
-            iter: self.inner.iter(),
-            comps_pd: PhantomData,
-        }
-    }
-
-    /// Iterates over the entities matching this query using the iterator returned by
-    /// `func`.
-    ///
-    /// This function exists so that a custom [`EntityHandle`] iterator can be given to
-    /// [`Iter`] without giving the user access to a reference to the [`World`].
-    #[must_use]
-    pub fn iter_with<'query, OutIter>(
-        &'query self,
-        func: impl FnOnce(FlexibleQueryIter<'query>) -> OutIter,
-    ) -> Iter<'query, 'world, FieldTerms, OutIter>
-    where
-        OutIter: Iterator<Item = EntityHandle<'query>>,
-    {
-        tracing::trace!("Searching for {}", std::any::type_name::<FieldTerms>());
-
-        Iter {
-            world: self.inner.world(),
-            inner: func(self.inner.iter()),
-            comps_pd: PhantomData,
-        }
-    }
-
-    /// Returns the UID of the entity at the given query iteration index.
-    #[must_use]
-    pub fn get_entity_uid(&self, entity_index: usize) -> Option<Uid>
-    {
-        Some(self.inner.iter().nth(entity_index)?.uid())
-    }
-
-    /// Returns a new `Query` created from a [`FlexibleQuery`].
-    ///
-    /// # Important notes
-    /// The terms in `FieldTerms` and `FieldlessTerms` must be compatible with the terms
-    /// in the given [`FlexibleQuery`], otherwise any method call or iterating might
-    /// panic.
-    #[must_use]
-    pub fn from_flexible_query(
-        flexible_query: FlexibleQuery<'world, MAX_TERM_CNT>,
-    ) -> Self
-    {
-        // TODO: Check compatability of terms
-
-        Self {
-            inner: flexible_query,
-            _pd: PhantomData,
-        }
-    }
-
-    pub(crate) fn new(world: &'world World) -> Self
-    {
-        let mut terms_builder = Terms::builder();
-
-        FieldTerms::apply_terms_to_builder(&mut terms_builder);
-        FieldlessTerms::apply_terms_to_builder(&mut terms_builder);
-
-        Self {
-            inner: world.flexible_query(terms_builder.build()),
-            _pd: PhantomData,
-        }
-    }
-}
-
-impl<'query, 'world, FieldTerms, FieldlessTerms> IntoIterator
-    for &'query Query<'world, FieldTerms, FieldlessTerms>
-where
-    FieldTerms: TermWithFieldTuple,
-    FieldlessTerms: TermWithoutFieldTuple,
-{
-    type IntoIter = Iter<'query, 'world, FieldTerms, FlexibleQueryIter<'query>>;
-    type Item = FieldTerms::Fields<'query>;
-
-    fn into_iter(self) -> Self::IntoIter
-    {
-        self.iter()
-    }
-}
-
-impl<'world, FieldTerms, FieldlessTerms> SystemParam<'world>
-    for Query<'world, FieldTerms, FieldlessTerms>
-where
-    FieldTerms: TermWithFieldTuple,
-    FieldlessTerms: TermWithoutFieldTuple,
-{
-    type Input = ();
-
-    fn new(world: &'world World, _system_metadata: &SystemMetadata) -> Self
-    {
-        Self::new(world)
-    }
-}
-
-#[derive(Debug)]
-pub struct Terms<const MAX_TERM_CNT: usize>
-{
-    required_components: ArrayVec<Uid, MAX_TERM_CNT>,
-    excluded_components: ArrayVec<Uid, MAX_TERM_CNT>,
-}
-
-impl<const MAX_TERM_CNT: usize> Terms<MAX_TERM_CNT>
-{
-    pub fn builder() -> TermsBuilder<MAX_TERM_CNT>
-    {
-        TermsBuilder::default()
-    }
-}
-
-#[derive(Debug, Default)]
-#[must_use]
-pub struct TermsBuilder<const MAX_TERM_CNT: usize>
-{
-    required_components: ArrayVec<Uid, MAX_TERM_CNT>,
-    excluded_components: ArrayVec<Uid, MAX_TERM_CNT>,
-}
-
-#[allow(clippy::return_self_not_must_use)]
-pub trait TermsBuilderInterface
-{
-    fn with<WithUidT: WithUid>(self) -> Self;
-
-    fn without<WithUidT: WithUid>(self) -> Self;
-
-    fn with_required(self, ids: impl Array<Uid>) -> Self;
-
-    fn without_ids(self, ids: impl Array<Uid>) -> Self;
-}
-
-macro_rules! impl_terms_builder {
-    ($($impl_content: tt)*) => {
-        impl<const MAX_TERM_CNT: usize>
-            TermsBuilderInterface for TermsBuilder<MAX_TERM_CNT>
-        {
-            $($impl_content)*
-        }
-
-        impl<const MAX_TERM_CNT: usize>
-            TermsBuilderInterface for &mut TermsBuilder<MAX_TERM_CNT>
-        {
-            $($impl_content)*
-        }
-    };
-}
-
-impl_terms_builder! {
-    #[allow(unused_mut)]
-    fn with<WithUidT: WithUid>(mut self) -> Self
-    {
-        let insert_index = self.required_components
-            .partition_point(|id| *id <= WithUidT::uid());
-
-        self.required_components
-            .insert(insert_index, WithUidT::uid());
-
-        self
-    }
-
-    #[allow(unused_mut)]
-    fn without<WithUidT: WithUid>(mut self) -> Self
-    {
-        let insert_index = self.excluded_components
-            .partition_point(|id| *id <= WithUidT::uid());
-
-        self.excluded_components
-            .insert(insert_index, WithUidT::uid());
-
-        self
-    }
-
-    #[allow(unused_mut)]
-    fn with_required(mut self, mut ids: impl Array<Uid>) -> Self
-    {
-        if !ids.as_ref().is_sorted() {
-            ids.as_mut().sort();
-        }
-
-        if self.required_components.is_empty() {
-            self.required_components.extend(ids);
-            return self;
-        }
-
-        let mut id_iter = ids.into_iter();
-
-        while let Some(id) = id_iter.next() {
-            let insert_index = self.required_components
-                .partition_point(|other_id| *other_id <= id);
-
-            if insert_index == self.required_components.len() {
-                self.required_components.extend([id].into_iter().chain(id_iter));
-
-                return self;
-            }
-
-            self.required_components
-                .insert(insert_index, id);
-
-        }
-
-        self
-    }
-
-    #[allow(unused_mut)]
-    fn without_ids(mut self, mut ids: impl Array<Uid>) -> Self
-    {
-        if !ids.as_ref().is_sorted() {
-            ids.as_mut().sort();
-        }
-
-        if self.excluded_components.is_empty() {
-            self.excluded_components.extend(ids);
-            return self;
-        }
-
-        let mut id_iter = ids.into_iter();
-
-        while let Some(id) = id_iter.next() {
-            let insert_index = self.excluded_components
-                .partition_point(|other_id| *other_id <= id);
-
-            if insert_index == self.excluded_components.len() {
-                self.excluded_components.extend([id].into_iter().chain(id_iter));
-
-                return self;
-            }
-
-            self.excluded_components
-                .insert(insert_index, id);
-
-        }
-
-        self
-    }
-}
-
-impl<const MAX_TERM_CNT: usize> TermsBuilder<MAX_TERM_CNT>
-{
-    #[must_use]
-    pub fn build(self) -> Terms<MAX_TERM_CNT>
-    {
-        debug_assert!(self.required_components.is_sorted());
-        debug_assert!(self.excluded_components.is_sorted());
-
-        Terms {
-            required_components: self.required_components,
-            excluded_components: self.excluded_components,
-        }
-    }
-}
-
-pub trait TermWithoutField
-{
-    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
-        terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
-    );
-}
-
-pub trait TermWithField
-{
-    type Field<'a>;
-
-    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
-        terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
-    );
-
-    fn get_field<'world>(
-        entity_handle: &EntityHandle<'world>,
-        world: &'world World,
-    ) -> Self::Field<'world>;
-}
-
-impl<ComponentT: Component> TermWithField for &ComponentT
-{
-    type Field<'a> = ComponentHandle<'a, ComponentT>;
-
-    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
-        terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
-    )
-    {
-        terms_builder.with::<ComponentT>();
-    }
-
-    fn get_field<'world>(
-        entity_handle: &EntityHandle<'world>,
-        _world: &'world World,
-    ) -> Self::Field<'world>
-    {
-        assert_eq!(ComponentT::id().kind(), UidKind::Component);
-
-        let Some(component) = entity_handle
-            .get_matching_components(ComponentT::id())
-            .next()
-        else {
-            panic!(
-                concat!(
-                    "Component {} was not found in entity {}. There ",
-                    "is most likely a bug in the entity querying"
-                ),
-                type_name::<ComponentT>(),
-                entity_handle.uid()
-            );
-        };
-
-        Self::Field::from_entity_component_ref(&component).unwrap_or_else(|err| {
-            panic!(
-                "Creating handle to component {} failed: {err}",
-                type_name::<ComponentT>()
-            );
-        })
-    }
-}
-
-impl<ComponentT: Component> TermWithField for &mut ComponentT
-{
-    type Field<'a> = ComponentHandleMut<'a, ComponentT>;
-
-    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
-        terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
-    )
-    {
-        terms_builder.with::<ComponentT>();
-    }
-
-    fn get_field<'world>(
-        entity_handle: &EntityHandle<'world>,
-        world: &'world World,
-    ) -> Self::Field<'world>
-    {
-        assert_eq!(ComponentT::id().kind(), UidKind::Component);
-
-        let Some(component) = entity_handle
-            .get_matching_components(ComponentT::id())
-            .next()
-        else {
-            panic!(
-                concat!(
-                    "Component {} was not found in entity {}. There ",
-                    "is most likely a bug in the entity querying"
-                ),
-                type_name::<ComponentT>(),
-                entity_handle.uid()
-            );
-        };
-
-        Self::Field::from_entity_component_ref(&component, world).unwrap_or_else(|err| {
-            panic!(
-                "Creating handle to component {} failed: {err}",
-                type_name::<ComponentT>()
-            );
-        })
-    }
-}
-
-pub trait TermWithoutFieldTuple
-{
-    fn apply_terms_to_builder<const MAX_TERM_CNT: usize>(
-        terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
-    );
-}
-
-pub trait TermWithFieldTuple
-{
-    type Fields<'component>;
-
-    fn apply_terms_to_builder<const MAX_TERM_CNT: usize>(
-        terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
-    );
-
-    fn get_fields<'component>(
-        entity_handle: &EntityHandle<'component>,
-        world: &'component World,
-    ) -> Self::Fields<'component>;
-}
-
-pub struct Iter<'query, 'world, FieldTerms, EntityHandleIter>
-where
-    FieldTerms: TermWithFieldTuple,
-    EntityHandleIter: Iterator<Item = EntityHandle<'query>>,
-{
-    world: &'world World,
-    inner: EntityHandleIter,
-    comps_pd: PhantomData<FieldTerms>,
-}
-
-impl<'query, 'world, FieldTerms, EntityHandleIter> Iterator
-    for Iter<'query, 'world, FieldTerms, EntityHandleIter>
-where
-    FieldTerms: TermWithFieldTuple,
-    EntityHandleIter: Iterator<Item = EntityHandle<'query>>,
-    'world: 'query,
-{
-    type Item = FieldTerms::Fields<'query>;
-
-    fn next(&mut self) -> Option<Self::Item>
-    {
-        let entity_handle = self.inner.next()?;
-
-        Some(FieldTerms::get_fields(&entity_handle, self.world))
-    }
-}
-
-pub struct ComponentAndEuidIter<'query, 'world, FieldTerms, EntityHandleIter>
-where
-    FieldTerms: TermWithFieldTuple,
-    EntityHandleIter: Iterator<Item = EntityHandle<'query>>,
-{
-    world: &'world World,
-    iter: EntityHandleIter,
-    comps_pd: PhantomData<FieldTerms>,
-}
-
-impl<'query, 'world, FieldTerms, EntityHandleIter> Iterator
-    for ComponentAndEuidIter<'query, 'world, FieldTerms, EntityHandleIter>
-where
-    FieldTerms: TermWithFieldTuple,
-    EntityHandleIter: Iterator<Item = EntityHandle<'query>>,
-    'world: 'query,
-{
-    type Item = (Uid, FieldTerms::Fields<'query>);
-
-    fn next(&mut self) -> Option<Self::Item>
-    {
-        let entity_handle = self.iter.next()?;
-
-        Some((
-            entity_handle.uid(),
-            FieldTerms::get_fields(&entity_handle, self.world),
-        ))
-    }
-}
-
-macro_rules! impl_term_sequence {
-    ($c: tt) => {
-        seq!(I in 0..=$c {
-            impl<#(Term~I: TermWithoutField,)*> TermWithoutFieldTuple for (#(Term~I,)*)
-            {
-                fn apply_terms_to_builder<const MAX_TERM_CNT: usize>(
-                    terms_builder: &mut TermsBuilder<MAX_TERM_CNT>
-                )
-                {
-                    #(
-                        Term~I::apply_to_terms_builder(terms_builder);
-                    )*
-                }
-            }
-
-            impl<#(Term~I: TermWithField,)*> TermWithFieldTuple for (#(Term~I,)*)
-            {
-                type Fields<'component> = (#(Term~I::Field<'component>,)*);
-
-                fn apply_terms_to_builder<const MAX_TERM_CNT: usize>(
-                    terms_builder: &mut TermsBuilder<MAX_TERM_CNT>
-                )
-                {
-                    #(
-                        Term~I::apply_to_terms_builder(terms_builder);
-                    )*
-                }
-
-                fn get_fields<'component>(
-                    entity_handle: &EntityHandle<'component>,
-                    world: &'component World,
-                ) -> Self::Fields<'component>
-                {
-                    (#(Term~I::get_field(entity_handle, world),)*)
-                }
-            }
-        });
-    };
-}
-
-seq!(C in 0..=16 {
-    impl_term_sequence!(C);
-});
-
-impl TermWithoutFieldTuple for ()
-{
-    fn apply_terms_to_builder<const MAX_TERM_CNT: usize>(
-        _terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
-    )
-    {
-    }
-}
-
-impl TermWithFieldTuple for ()
-{
-    type Fields<'component> = ();
-
-    fn apply_terms_to_builder<const MAX_TERM_CNT: usize>(
-        _terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
-    )
-    {
-    }
-
-    fn get_fields<'component>(
-        _entity_handle: &EntityHandle<'_>,
-        _world: &'component World,
-    ) -> Self::Fields<'component>
-    {
-    }
-}
diff --git a/ecs/src/query/flexible.rs b/ecs/src/query/flexible.rs
deleted file mode 100644
index 936ab82..0000000
--- a/ecs/src/query/flexible.rs
+++ /dev/null
@@ -1,92 +0,0 @@
-//! Low-level querying.
-use std::iter::{repeat_n, FlatMap, RepeatN, Zip};
-
-use crate::component::storage::archetype::{Archetype, EntityIter};
-use crate::component::storage::{ArchetypeRefIter, ArchetypeSearchTerms};
-use crate::entity::Handle as EntityHandle;
-use crate::query::Terms;
-use crate::World;
-
-/// Low-level entity query structure.
-#[derive(Debug)]
-pub struct Query<'world, const MAX_TERM_CNT: usize>
-{
-    world: &'world World,
-    terms: Terms<MAX_TERM_CNT>,
-}
-
-impl<'world, const MAX_TERM_CNT: usize> Query<'world, MAX_TERM_CNT>
-{
-    /// Iterates over the entities matching this query.
-    #[must_use]
-    pub fn iter(&self) -> Iter<'_>
-    {
-        Iter {
-            iter: self
-                .world
-                .data
-                .component_storage
-                .search_archetypes(ArchetypeSearchTerms {
-                    required_components: &self.terms.required_components,
-                    excluded_components: &self.terms.excluded_components,
-                })
-                .flat_map(
-                    (|archetype| {
-                        repeat_n(archetype, archetype.entity_cnt())
-                            .zip(archetype.entities())
-                    }) as ComponentIterMapFn,
-                ),
-            world: self.world,
-        }
-    }
-
-    #[must_use]
-    pub fn world(&self) -> &'world World
-    {
-        self.world
-    }
-
-    pub(crate) fn new(world: &'world World, terms: Terms<MAX_TERM_CNT>) -> Self
-    {
-        Self { world, terms }
-    }
-}
-
-impl<'query, const MAX_TERM_CNT: usize> IntoIterator for &'query Query<'_, MAX_TERM_CNT>
-{
-    type IntoIter = Iter<'query>;
-    type Item = EntityHandle<'query>;
-
-    fn into_iter(self) -> Self::IntoIter
-    {
-        self.iter()
-    }
-}
-
-pub struct Iter<'query>
-{
-    iter: QueryEntityIter<'query>,
-    world: &'query World,
-}
-
-impl<'query> Iterator for Iter<'query>
-{
-    type Item = EntityHandle<'query>;
-
-    fn next(&mut self) -> Option<Self::Item>
-    {
-        let (archetype, entity) = self.iter.next()?;
-
-        Some(EntityHandle::new(archetype, entity, self.world))
-    }
-}
-
-type ComponentIterMapFnOutput<'a> = Zip<RepeatN<&'a Archetype>, EntityIter<'a>>;
-
-type ComponentIterMapFn = for<'a> fn(&'a Archetype) -> ComponentIterMapFnOutput<'a>;
-
-type QueryEntityIter<'query> = FlatMap<
-    ArchetypeRefIter<'query, 'query>,
-    ComponentIterMapFnOutput<'query>,
-    ComponentIterMapFn,
->;
diff --git a/ecs/src/query/term.rs b/ecs/src/query/term.rs
deleted file mode 100644
index 0683918..0000000
--- a/ecs/src/query/term.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-use std::any::type_name;
-use std::marker::PhantomData;
-
-use crate::component::{
-    Component,
-    Handle as ComponentHandle,
-    HandleMut as ComponentHandleMut,
-};
-use crate::query::{
-    TermWithField,
-    TermWithoutField,
-    TermsBuilder,
-    TermsBuilderInterface,
-};
-use crate::uid::With as WithUid;
-
-pub struct With<WithUidT>
-where
-    WithUidT: WithUid,
-{
-    _pd: PhantomData<WithUidT>,
-}
-
-impl<WithUidT> TermWithoutField for With<WithUidT>
-where
-    WithUidT: WithUid,
-{
-    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
-        terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
-    )
-    {
-        terms_builder.with::<WithUidT>();
-    }
-}
-
-pub struct Without<WithUidT>
-where
-    WithUidT: WithUid,
-{
-    _pd: PhantomData<WithUidT>,
-}
-
-impl<WithUidT> TermWithoutField for Without<WithUidT>
-where
-    WithUidT: WithUid,
-{
-    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
-        terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
-    )
-    {
-        terms_builder.without::<WithUidT>();
-    }
-}
-
-impl<ComponentT: Component> TermWithField for Option<&ComponentT>
-{
-    type Field<'a> = Option<ComponentHandle<'a, ComponentT>>;
-
-    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
-        _terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
-    )
-    {
-    }
-
-    fn get_field<'world>(
-        entity_handle: &crate::entity::Handle<'world>,
-        _world: &'world crate::World,
-    ) -> Self::Field<'world>
-    {
-        Some(
-            ComponentHandle::<'world, ComponentT>::from_entity_component_ref(
-                &entity_handle
-                    .get_matching_components(ComponentT::id())
-                    .next()?,
-            )
-            .unwrap_or_else(|err| {
-                panic!(
-                    "Creating handle to component {} failed: {err}",
-                    type_name::<ComponentT>()
-                );
-            }),
-        )
-    }
-}
-
-impl<ComponentT: Component> TermWithField for Option<&mut ComponentT>
-{
-    type Field<'a> = Option<ComponentHandleMut<'a, ComponentT>>;
-
-    fn apply_to_terms_builder<const MAX_TERM_CNT: usize>(
-        _terms_builder: &mut TermsBuilder<MAX_TERM_CNT>,
-    )
-    {
-    }
-
-    fn get_field<'world>(
-        entity_handle: &crate::entity::Handle<'world>,
-        world: &'world crate::World,
-    ) -> Self::Field<'world>
-    {
-        Some(
-            ComponentHandleMut::<'world, ComponentT>::from_entity_component_ref(
-                &entity_handle
-                    .get_matching_components(ComponentT::id())
-                    .next()?,
-                world,
-            )
-            .unwrap_or_else(|err| {
-                panic!(
-                    "Creating handle to component {} failed: {err}",
-                    type_name::<ComponentT>()
-                );
-            }),
-        )
-    }
-}
diff --git a/ecs/src/sole.rs b/ecs/src/sole.rs
deleted file mode 100644
index 82e5e0f..0000000
--- a/ecs/src/sole.rs
+++ /dev/null
@@ -1,104 +0,0 @@
-use std::any::{Any, type_name};
-use std::fmt::Debug;
-use std::marker::PhantomData;
-use std::ops::{Deref, DerefMut};
-use std::sync::Arc;
-
-use crate::World;
-use crate::lock::{Lock, WriteGuard};
-use crate::system::{Metadata as SystemMetadata, Param as SystemParam};
-
-/// A type which has a single instance and is shared globally.
-pub trait Sole: Any
-{
-    fn drop_last(&self) -> bool;
-
-    fn as_any_mut(&mut self) -> &mut dyn Any;
-
-    fn as_any(&self) -> &dyn Any;
-}
-
-impl dyn Sole
-{
-    pub fn downcast_mut<Real: 'static>(&mut self) -> Option<&mut Real>
-    {
-        self.as_any_mut().downcast_mut()
-    }
-
-    pub fn downcast_ref<Real: 'static>(&self) -> Option<&Real>
-    {
-        self.as_any().downcast_ref()
-    }
-}
-
-impl Debug for dyn Sole
-{
-    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
-    {
-        formatter.debug_struct("Sole").finish_non_exhaustive()
-    }
-}
-
-/// Holds a reference to a globally shared singleton value.
-#[derive(Debug)]
-pub struct Single<'world, SoleT: Sole>
-{
-    sole: WriteGuard<'world, Box<dyn Sole>>,
-    _ph: PhantomData<SoleT>,
-}
-
-impl<'world, SoleT> Single<'world, SoleT>
-where
-    SoleT: Sole,
-{
-    pub(crate) fn new(sole: &'world Arc<Lock<Box<dyn Sole>>>) -> Self
-    {
-        Self {
-            sole: sole.write_nonblock().unwrap_or_else(|_| {
-                panic!(
-                    "Failed to aquire read-write lock to single component {}",
-                    type_name::<SoleT>()
-                )
-            }),
-            _ph: PhantomData,
-        }
-    }
-}
-
-impl<'world, SoleT> SystemParam<'world> for Single<'world, SoleT>
-where
-    SoleT: Sole,
-{
-    type Input = ();
-
-    fn new(world: &'world World, _system_metadata: &SystemMetadata) -> Self
-    {
-        let sole = world.data.sole_storage.get::<SoleT>().unwrap_or_else(|| {
-            panic!("Sole {} was not found in world", type_name::<SoleT>())
-        });
-
-        Self::new(sole)
-    }
-}
-
-impl<SoleT> Deref for Single<'_, SoleT>
-where
-    SoleT: Sole,
-{
-    type Target = SoleT;
-
-    fn deref(&self) -> &Self::Target
-    {
-        self.sole.downcast_ref().unwrap()
-    }
-}
-
-impl<SoleT> DerefMut for Single<'_, SoleT>
-where
-    SoleT: Sole,
-{
-    fn deref_mut(&mut self) -> &mut Self::Target
-    {
-        self.sole.downcast_mut().unwrap()
-    }
-}
diff --git a/ecs/src/stats.rs b/ecs/src/stats.rs
deleted file mode 100644
index 56a5c32..0000000
--- a/ecs/src/stats.rs
+++ /dev/null
@@ -1,8 +0,0 @@
-use ecs_macros::Sole;
-
-#[derive(Debug, Default, Sole)]
-#[non_exhaustive]
-pub struct Stats
-{
-    pub current_tick: u64,
-}
diff --git a/ecs/src/system.rs b/ecs/src/system.rs
deleted file mode 100644
index 5d3e0bf..0000000
--- a/ecs/src/system.rs
+++ /dev/null
@@ -1,158 +0,0 @@
-use std::fmt::Debug;
-
-use ecs_macros::Component;
-use seq_macro::seq;
-
-use crate::World;
-use crate::error::Error;
-use crate::uid::Uid;
-
-pub mod initializable;
-pub mod observer;
-pub mod stateful;
-
-/// Metadata of a system.
-#[derive(Debug)]
-#[non_exhaustive]
-pub struct Metadata
-{
-    pub ent_id: Uid,
-}
-
-pub trait System<'world, Impl>: 'static
-{
-    type Callbacks: Callbacks;
-
-    fn finish(self) -> (TypeErased, Self::Callbacks);
-}
-
-macro_rules! impl_system {
-    ($c: tt) => {
-        seq!(I in 0..$c {
-            impl<'world, Func, Ret, #(TParam~I,)*> System<'world, fn(#(TParam~I,)*) -> Ret>
-                for Func
-            where
-                Func: Fn(#(TParam~I,)*) -> Ret + 'static,
-                Ret: ReturnValue,
-                #(TParam~I: Param<'world, Input = ()>,)*
-            {
-                type Callbacks = NoCallbacks;
-
-                fn finish(self) -> (TypeErased, Self::Callbacks)
-                {
-                    #![allow(unused)]
-
-                    let type_erased = TypeErased {
-                        run: Box::new(move |world, metadata| {
-                            // SAFETY: The caller of TypeErased::run ensures the lifetime
-                            // is correct
-                            let world = unsafe { &*std::ptr::from_ref(world) };
-
-                            self(#({
-                                TParam~I::new(world, &metadata)
-                            },)*).into_result()
-                        }),
-                        name: std::any::type_name::<Self>()
-                    };
-
-                    (type_erased, NoCallbacks)
-                }
-            }
-        });
-    };
-}
-
-seq!(C in 0..16 {
-    impl_system!(C);
-});
-
-pub trait Into<'world, Impl>
-{
-    type System;
-
-    fn into_system(self) -> Self::System;
-}
-
-pub struct TypeErased
-{
-    run: Box<TypeErasedRunFn>,
-    name: &'static str,
-}
-
-impl TypeErased
-{
-    /// Runs the system.
-    ///
-    /// # Safety
-    /// `world_data` must live at least as long as the [`World`] the system belongs to.
-    pub unsafe fn run(&self, world: &World, metadata: Metadata) -> Result<(), Error>
-    {
-        (self.run)(world, metadata)
-    }
-
-    pub fn name(&self) -> &'static str
-    {
-        self.name
-    }
-}
-
-impl Debug for TypeErased
-{
-    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
-    {
-        formatter.debug_struct("TypeErased").finish_non_exhaustive()
-    }
-}
-
-pub trait ReturnValue
-{
-    fn into_result(self) -> Result<(), Error>;
-}
-
-impl ReturnValue for ()
-{
-    fn into_result(self) -> Result<(), Error>
-    {
-        Ok(())
-    }
-}
-
-impl ReturnValue for Result<(), Error>
-{
-    fn into_result(self) -> Result<(), Error>
-    {
-        self
-    }
-}
-
-/// A parameter to a [`System`].
-pub trait Param<'world>
-{
-    type Input;
-
-    fn new(world: &'world World, system_metadata: &Metadata) -> Self;
-}
-
-/// A type which can be used as input to a [`System`].
-pub trait Input: 'static {}
-
-pub trait Callbacks
-{
-    fn on_created(&mut self, world: &mut World, metadata: Metadata);
-}
-
-pub struct NoCallbacks;
-
-impl Callbacks for NoCallbacks
-{
-    fn on_created(&mut self, _world: &mut World, _metadata: Metadata) {}
-}
-
-#[derive(Debug, Component)]
-pub(crate) struct SystemComponent
-{
-    pub(crate) system: TypeErased,
-}
-
-/// Function in [`TypeErased`] used to run the system.
-type TypeErasedRunFn = dyn Fn(&World, Metadata) -> Result<(), Error>;
diff --git a/ecs/src/system/initializable.rs b/ecs/src/system/initializable.rs
deleted file mode 100644
index b6ec8e8..0000000
--- a/ecs/src/system/initializable.rs
+++ /dev/null
@@ -1,131 +0,0 @@
-use std::marker::PhantomData;
-
-use seq_macro::seq;
-
-use crate::system::{Input, Param as SystemParam, System};
-use crate::tuple::{Reduce as TupleReduce, ReduceElement as TupleReduceElement, Tuple};
-
-/// A initializable system.
-pub trait Initializable<'world, Impl>: System<'world, Impl>
-{
-    type Inputs;
-
-    #[must_use]
-    fn initialize(self, inputs: Self::Inputs) -> Self;
-}
-
-pub trait Param<'world, SystemT>: SystemParam<'world>
-{
-    fn initialize(system: &mut SystemT, input: Self::Input);
-}
-
-pub struct ParamTupleFilter<'world, SystemT>
-{
-    _pd: PhantomData<(&'world (), SystemT)>,
-}
-
-impl<'world, SystemT, ParamT, Accumulator>
-    TupleReduceElement<Accumulator, ParamTupleFilter<'world, SystemT>> for ParamT
-where
-    ParamT: SystemParam<
-        'world,
-        Input: AppendInitializableParam<'world, Accumulator, ParamT, SystemT>,
-    >,
-    Accumulator: Tuple,
-{
-    type Return = <ParamT::Input as AppendInitializableParam<
-        'world,
-        Accumulator,
-        ParamT,
-        SystemT,
-    >>::Return;
-}
-
-pub trait AppendInitializableParam<'world, Accumulator, ParamT, SystemT>
-{
-    type Return;
-}
-
-impl<'world, InputT, ParamT, Accumulator, SystemT>
-    AppendInitializableParam<'world, Accumulator, ParamT, SystemT> for InputT
-where
-    InputT: Input,
-    Accumulator: Tuple,
-    ParamT: Param<'world, SystemT>,
-{
-    type Return = Accumulator::WithElementAtEnd<ParamT>;
-}
-
-impl<ParamT, Accumulator, SystemT>
-    AppendInitializableParam<'_, Accumulator, ParamT, SystemT> for ()
-where
-    Accumulator: Tuple,
-{
-    type Return = Accumulator;
-}
-
-pub trait ParamTuple<'world, SystemT>
-{
-    type Inputs;
-
-    fn initialize_all(system: &mut SystemT, inputs: Self::Inputs);
-}
-
-macro_rules! impl_initializable_param_tuple {
-    ($c: tt) => {
-        seq!(I in 0..$c {
-            impl<'world, SystemT, #(Param~I,)*> ParamTuple<'world, SystemT>
-                for (#(Param~I,)*)
-            where
-                #(Param~I: Param<'world, SystemT>,)*
-            {
-                type Inputs = (#(Param~I::Input,)*);
-
-                fn initialize_all(
-                    system: &mut SystemT,
-                    inputs: Self::Inputs,
-                ) {
-                    #(
-                        <Param~I as Param<'world, SystemT>>::initialize(
-                            system,
-                            inputs.I
-                        );
-                    )*
-                }
-            }
-        });
-    };
-}
-
-seq!(C in 1..16 {
-    impl_initializable_param_tuple!(C);
-});
-
-impl<SystemT> ParamTuple<'_, SystemT> for ()
-{
-    type Inputs = ();
-
-    fn initialize_all(_system: &mut SystemT, _inputs: Self::Inputs) {}
-}
-
-/// A tuple of system parameters that may or may not be initializable.
-pub trait MaybeInitializableParamTuple<'world, SystemT>
-{
-    /// A tuple of the inputs of the initializable system parameters in this tuple.
-    type Inputs;
-
-    fn init_initializable(system: &mut SystemT, inputs: Self::Inputs);
-}
-
-impl<'world, SystemT, Params> MaybeInitializableParamTuple<'world, SystemT> for Params
-where
-    Params:
-        TupleReduce<ParamTupleFilter<'world, SystemT>, Out: ParamTuple<'world, SystemT>>,
-{
-    type Inputs = <Params::Out as ParamTuple<'world, SystemT>>::Inputs;
-
-    fn init_initializable(system: &mut SystemT, inputs: Self::Inputs)
-    {
-        Params::Out::initialize_all(system, inputs);
-    }
-}
diff --git a/ecs/src/system/observer.rs b/ecs/src/system/observer.rs
deleted file mode 100644
index 6893b0f..0000000
--- a/ecs/src/system/observer.rs
+++ /dev/null
@@ -1,280 +0,0 @@
-use std::any::type_name;
-use std::fmt::Debug;
-use std::marker::PhantomData;
-use std::mem::transmute;
-use std::slice::Iter as SliceIter;
-
-use ecs_macros::Component;
-use seq_macro::seq;
-
-use crate::World;
-use crate::component::Component;
-use crate::entity::Handle as EntityHandle;
-use crate::error::Error;
-use crate::event::Emitted as EmittedEvent;
-use crate::pair::Pair;
-use crate::system::{
-    Metadata,
-    NoCallbacks,
-    Param,
-    ReturnValue as SystemReturnValue,
-    System,
-    TypeErased as TypeErasedSystem,
-};
-use crate::uid::Uid;
-use crate::util::Array;
-
-pub trait Observed
-{
-    type Events: Array<Pair<Uid, Uid>>;
-
-    fn events() -> Self::Events;
-}
-
-impl<Relation, Target> Observed for Pair<Relation, Target>
-where
-    Relation: Component,
-    Target: Component,
-{
-    type Events = [Pair<Uid, Uid>; 1];
-
-    fn events() -> Self::Events
-    {
-        [Pair::builder()
-            .relation::<Relation>()
-            .target::<Target>()
-            .build()]
-    }
-}
-
-/// Observer system.
-pub trait Observer<'world, Impl>: System<'world, Impl>
-{
-    type ObservedEvents: Array<Pair<Uid, Uid>>;
-
-    fn observed_events() -> Self::ObservedEvents;
-
-    fn finish_observer(self) -> (WrapperComponent, Self::Callbacks);
-}
-
-pub struct Observe<'world, ObservedT: Observed>
-{
-    _pd: PhantomData<ObservedT>,
-    world: &'world World,
-    emitted_event: EmittedEvent<'world>,
-}
-
-impl<'world, ObservedT: Observed> Observe<'world, ObservedT>
-{
-    pub fn new(world: &'world World, emitted_event: EmittedEvent<'world>) -> Self
-    {
-        Self {
-            _pd: PhantomData,
-            world,
-            emitted_event,
-        }
-    }
-
-    #[must_use]
-    pub fn event(&self) -> Uid
-    {
-        self.emitted_event.event
-    }
-}
-
-impl<ObservedT: Observed> Observe<'_, ObservedT>
-{
-    #[must_use]
-    pub fn iter(&self) -> ObserveIter<'_, ObservedT>
-    {
-        ObserveIter {
-            world: self.world,
-            inner: self.emitted_event.match_ids.iter(),
-            _pd: PhantomData,
-        }
-    }
-}
-
-impl<'a, ObservedT: Observed> IntoIterator for &'a Observe<'_, ObservedT>
-{
-    type IntoIter = ObserveIter<'a, ObservedT>;
-    type Item = <Self::IntoIter as Iterator>::Item;
-
-    fn into_iter(self) -> Self::IntoIter
-    {
-        self.iter()
-    }
-}
-
-pub struct ObserveIter<'observe, ObservedT: Observed>
-{
-    world: &'observe World,
-    inner: SliceIter<'observe, Uid>,
-    _pd: PhantomData<ObservedT>,
-}
-
-impl<'observe, ObservedT: Observed> Iterator for ObserveIter<'observe, ObservedT>
-{
-    type Item = EventMatch<'observe, ObservedT>;
-
-    fn next(&mut self) -> Option<Self::Item>
-    {
-        let match_id = *self.inner.next()?;
-
-        Some(EventMatch {
-            world: self.world,
-            id: match_id,
-            _pd: PhantomData,
-        })
-    }
-}
-
-/// A event match.
-#[derive(Debug)]
-pub struct EventMatch<'world, ObservedT: Observed>
-{
-    world: &'world World,
-    id: Uid,
-    _pd: PhantomData<ObservedT>,
-}
-
-impl<'world, ObservedT: Observed> EventMatch<'world, ObservedT>
-{
-    #[must_use]
-    pub fn entity_id(&self) -> Uid
-    {
-        self.id
-    }
-
-    /// Attempts to get the entity with the id of this match.
-    #[must_use]
-    pub fn try_get_entity(&self) -> Option<EntityHandle<'world>>
-    {
-        self.world.get_entity(self.id)
-    }
-}
-
-macro_rules! impl_observer {
-    ($c: tt) => {
-        seq!(I in 0..$c {
-            impl<'world, ObservedT, Func, Ret, #(TParam~I,)*> System<
-                'world,
-                fn(Observe<'world, ObservedT>, #(TParam~I,)*) -> Ret
-            > for Func
-            where
-                ObservedT: Observed,
-                Func: Fn(Observe<'world, ObservedT>, #(TParam~I,)*) -> Ret + 'static,
-                Ret: SystemReturnValue,
-                #(TParam~I: Param<'world, Input = ()>,)*
-            {
-                type Callbacks = NoCallbacks;
-
-                fn finish(self) -> (TypeErasedSystem, NoCallbacks)
-                {
-                    const {
-                        panic!("Observers cannot be used as regular systems");
-                    }
-                }
-            }
-
-            impl<'world, ObservedT, Func, Ret, #(TParam~I,)*> Observer<
-                'world,
-                fn(Observe<'world, ObservedT>, #(TParam~I,)*) -> Ret
-            > for Func
-            where
-                ObservedT: Observed,
-                Func: Fn(Observe<'world, ObservedT>, #(TParam~I,)*) -> Ret + 'static,
-                Ret: SystemReturnValue,
-                #(TParam~I: Param<'world, Input = ()>,)*
-            {
-                type ObservedEvents = ObservedT::Events;
-
-                fn observed_events() -> Self::ObservedEvents
-                {
-                    ObservedT::events()
-                }
-
-                fn finish_observer(self) -> (WrapperComponent, NoCallbacks)
-                {
-                    #[allow(unused)]
-
-                    let wrapper_comp = WrapperComponent::new(
-                        move |world, metadata, emitted_event| {
-                            // SAFETY: The caller of TypeErased::run ensures the lifetime
-                            // is correct
-                            let world = unsafe { &*std::ptr::from_ref(world) };
-
-                            // SAFETY: The caller of TypeErased::run ensures the lifetime
-                            // is correct
-                            let emitted_event = unsafe {
-                                transmute::<EmittedEvent<'_>, EmittedEvent<'_>>(
-                                    emitted_event
-                                )
-                            };
-
-                            self(Observe::new(world, emitted_event), #({
-                                TParam~I::new(world, &metadata)
-                            },)*).into_result()
-                        },
-                        type_name::<Func>()
-                    );
-
-                    (wrapper_comp, NoCallbacks)
-                }
-            }
-        });
-    };
-}
-
-seq!(C in 0..16 {
-    impl_observer!(C);
-});
-
-#[derive(Component)]
-pub struct WrapperComponent
-{
-    run: Box<RunFn>,
-    name: &'static str,
-}
-
-impl WrapperComponent
-{
-    pub fn new(
-        run: impl Fn(&World, Metadata, EmittedEvent<'_>) -> Result<(), Error> + 'static,
-        name: &'static str,
-    ) -> Self
-    {
-        Self { run: Box::new(run), name }
-    }
-
-    /// Runs the observer system.
-    ///
-    /// # Safety
-    /// `world` must live at least as long as the [`World`] the system belongs to.
-    pub unsafe fn run(
-        &self,
-        world: &World,
-        metadata: Metadata,
-        emitted_event: EmittedEvent<'_>,
-    ) -> Result<(), Error>
-    {
-        (self.run)(world, metadata, emitted_event)
-    }
-
-    pub fn name(&self) -> &'static str
-    {
-        self.name
-    }
-}
-
-impl Debug for WrapperComponent
-{
-    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result
-    {
-        formatter
-            .debug_struct("WrapperComponent")
-            .finish_non_exhaustive()
-    }
-}
-
-type RunFn = dyn Fn(&World, Metadata, EmittedEvent<'_>) -> Result<(), Error>;
diff --git a/ecs/src/system/stateful.rs b/ecs/src/system/stateful.rs
deleted file mode 100644
index 3e0076a..0000000
--- a/ecs/src/system/stateful.rs
+++ /dev/null
@@ -1,269 +0,0 @@
-use std::any::type_name;
-use std::mem::transmute;
-
-use seq_macro::seq;
-
-use crate::World;
-use crate::component::Parts as ComponentParts;
-use crate::component::local::SystemWithLocalComponents;
-use crate::event::Emitted as EmittedEvent;
-use crate::system::initializable::{Initializable, MaybeInitializableParamTuple};
-use crate::system::observer::{
-    Observe,
-    Observed,
-    Observer,
-    WrapperComponent as ObserverWrapperComponent,
-};
-use crate::system::{
-    Into as IntoSystem,
-    Metadata,
-    Param,
-    ReturnValue,
-    System,
-    TypeErased,
-};
-
-/// A stateful system.
-pub struct Stateful<Func>
-{
-    func: Func,
-    local_components: Vec<ComponentParts>,
-}
-
-macro_rules! impl_system {
-    ($c: tt) => {
-        seq!(I in 0..$c {
-            impl<'world, Func, Ret, #(TParam~I,)*>
-                System<'world, fn(#(TParam~I,)*) -> Ret> for Stateful<Func>
-            where
-                Func: Fn(#(TParam~I,)*) -> Ret + 'static,
-                Ret: ReturnValue,
-                #(TParam~I: Param<'world, Input: 'static>,)*
-            {
-                type Callbacks = Callbacks;
-
-                fn finish(self) -> (TypeErased, Self::Callbacks)
-                {
-                    let Self { func, local_components } = self;
-
-                    let callbacks = Callbacks { local_components };
-
-                    let type_erased = TypeErased {
-                        run: Box::new(move |world, metadata| {
-                            // SAFETY: The caller of TypeErased::run ensures the lifetime
-                            // is correct
-                            let world = unsafe { &*std::ptr::from_ref(world) };
-
-                            func(#({
-                                TParam~I::new(&world, &metadata)
-                            },)*);
-
-                            Ok(())
-                        }),
-                        name: type_name::<Func>()
-                    };
-
-
-                    (type_erased, callbacks)
-                }
-            }
-
-            impl<'world, Func, Ret, #(TParam~I,)*>
-                Initializable<'world, fn(#(TParam~I,)*) -> Ret> for Stateful<Func>
-            where
-                Func: Fn(#(TParam~I,)*) -> Ret + 'static,
-                Ret: ReturnValue,
-                #(TParam~I: Param<'world, Input: 'static>,)*
-                (#(TParam~I,)*): MaybeInitializableParamTuple<'world, Self>
-            {
-                type Inputs = <
-                    (#(TParam~I,)*) as MaybeInitializableParamTuple<'world, Self>
-                >::Inputs;
-
-                fn initialize(mut self, inputs: Self::Inputs) -> Self
-                {
-                    init_initializable_params::<_, (#(TParam~I,)*)>(&mut self, inputs);
-
-                    self
-                }
-            }
-
-            impl<'world, Func, Ret, #(TParam~I,)*>
-                IntoSystem<'world, fn(#(TParam~I,)*) -> Ret> for Func
-            where
-                Func: Fn(#(TParam~I,)*) -> Ret + 'static,
-                Ret: ReturnValue,
-                #(TParam~I: Param<'world>,)*
-            {
-                type System = Stateful<Func>;
-
-                fn into_system(self) -> Self::System
-                {
-                    Self::System {
-                        func: self,
-                        local_components: Vec::new(), // TODO: Use Vec::with_capacity
-                    }
-                }
-            }
-        });
-    };
-}
-
-seq!(C in 1..16 {
-    impl_system!(C);
-});
-
-impl<Func> SystemWithLocalComponents for Stateful<Func>
-{
-    fn add_local_component(&mut self, component_parts: ComponentParts)
-    {
-        self.local_components.push(component_parts);
-    }
-}
-
-#[derive(Debug)]
-pub struct Callbacks
-{
-    local_components: Vec<ComponentParts>,
-}
-
-impl crate::system::Callbacks for Callbacks
-{
-    fn on_created(&mut self, world: &mut World, metadata: Metadata)
-    {
-        for local_comp_parts in self.local_components.drain(..) {
-            world.add_component(metadata.ent_id, local_comp_parts);
-        }
-    }
-}
-
-fn init_initializable_params<'world, SystemT, Params>(
-    system: &mut SystemT,
-    inputs: Params::Inputs,
-) where
-    Params: MaybeInitializableParamTuple<'world, SystemT>,
-{
-    Params::init_initializable(system, inputs);
-}
-
-macro_rules! impl_observer {
-    ($c: tt) => {
-        seq!(I in 0..$c {
-            impl<'world, ObservedT, Func, Ret, #(TParam~I,)*> System<
-                'world,
-                fn(Observe<'world, ObservedT>, #(TParam~I,)*) -> Ret
-            > for Stateful<Func>
-            where
-                ObservedT: Observed,
-                Func: Fn(Observe<'world, ObservedT>, #(TParam~I,)*) -> Ret + 'static,
-                Ret: ReturnValue,
-                #(TParam~I: Param<'world>,)*
-            {
-                type Callbacks = Callbacks;
-
-                fn finish(self) -> (TypeErased, Callbacks)
-                {
-                    unimplemented!();
-                }
-            }
-
-            impl<'world, ObservedT, Func, Ret, #(TParam~I,)*> Initializable<
-                'world,
-                fn(Observe<'world, ObservedT>, #(TParam~I,)*) -> Ret
-            > for Stateful<Func>
-            where
-                ObservedT: Observed,
-                Func: Fn(Observe<'world, ObservedT>, #(TParam~I,)*) -> Ret + 'static,
-                Ret: ReturnValue,
-                #(TParam~I: Param<'world>,)*
-                (#(TParam~I,)*): MaybeInitializableParamTuple<'world, Self>
-            {
-                type Inputs = <
-                    (#(TParam~I,)*) as MaybeInitializableParamTuple<'world, Self>
-                >::Inputs;
-
-                fn initialize(mut self, inputs: Self::Inputs) -> Self
-                {
-                    init_initializable_params::<_, (#(TParam~I,)*)>(&mut self, inputs);
-
-                    self
-                }
-            }
-
-            impl<'world, ObservedT, Func, Ret, #(TParam~I,)*> Observer<
-                'world,
-                fn(Observe<'world, ObservedT>, #(TParam~I,)*) -> Ret
-            > for Stateful<Func>
-            where
-                ObservedT: Observed,
-                Func: Fn(Observe<'world, ObservedT>, #(TParam~I,)*) -> Ret + 'static,
-                Ret: ReturnValue,
-                #(TParam~I: Param<'world>,)*
-            {
-                type ObservedEvents = ObservedT::Events;
-
-                fn observed_events() -> Self::ObservedEvents
-                {
-                    ObservedT::events()
-                }
-
-                fn finish_observer(self) -> (ObserverWrapperComponent, Callbacks)
-                {
-                    #![allow(unused)]
-
-                    let Self { func, local_components } = self;
-
-                    let callbacks = Callbacks { local_components };
-
-                    let wrapper_comp = ObserverWrapperComponent::new(
-                        move |world, metadata, emitted_event| {
-                            // SAFETY: The caller of TypeErased::run ensures the lifetime
-                            // is correct
-                            let world = unsafe { &*std::ptr::from_ref(world) };
-
-                            // SAFETY: The caller of TypeErased::run ensures the lifetime
-                            // is correct
-                            let emitted_event = unsafe {
-                                transmute::<EmittedEvent<'_>, EmittedEvent<'_>>(
-                                    emitted_event
-                                )
-                            };
-
-                            func(Observe::new(world, emitted_event), #({
-                                TParam~I::new(world, &metadata)
-                            },)*).into_result()
-                        },
-                        type_name::<Func>()
-                    );
-
-                    (wrapper_comp, callbacks)
-                }
-            }
-
-            impl<'world, Func, Ret, ObservedT, #(TParam~I,)*> IntoSystem<
-                'world,
-                fn(Observe<'world, ObservedT>, #(TParam~I,)*) -> Ret
-            > for Func
-            where
-                ObservedT: Observed,
-                Func: Fn(Observe<'world, ObservedT>, #(TParam~I,)*) -> Ret + 'static,
-                Ret: ReturnValue,
-                #(TParam~I: Param<'world>,)*
-            {
-                type System = Stateful<Func>;
-
-                fn into_system(self) -> Stateful<Func>
-                {
-                    Stateful {
-                        func: self,
-                        local_components: Vec::new(), // TODO: Use Vec::with_capacity
-                    }
-                }
-            }
-        });
-    };
-}
-
-seq!(C in 0..16 {
-    impl_observer!(C);
-});
diff --git a/ecs/src/tuple.rs b/ecs/src/tuple.rs
deleted file mode 100644
index def25a0..0000000
--- a/ecs/src/tuple.rs
+++ /dev/null
@@ -1,238 +0,0 @@
-use std::any::TypeId;
-
-use paste::paste;
-use seq_macro::seq;
-use util_macros::sub;
-
-pub trait Tuple: sealed::Sealed
-{
-    /// `Self` with the given type added as the last element.
-    ///
-    /// `(String, i32, u8)::WithElementAtEnd<Path> = (String, i32, u8, Path)`
-    ///
-    /// # Important note
-    /// If `Self` has 16 elements, this will be `()`. The reason for this is that the
-    /// `Tuple` trait is only implemented for tuples with up to and including 16 elements.
-    type WithElementAtEnd<NewElem>: Tuple;
-
-    /// `Self` without the last element.
-    ///
-    /// `(u16, AtomicU8)::WithoutLastElement = (u16,)`
-    type WithoutLastElement: Tuple;
-
-    /// The last element of `Self`.
-    type LastElement;
-
-    /// Self with all elements wrapped in [`Option`].
-    type InOptions: Tuple;
-
-    /// Pops the last element from this tuple, returning the new tuple and the popped
-    /// element.
-    fn pop_last(self) -> (Self::WithoutLastElement, Self::LastElement);
-
-    /// Converts this tuple so that all elements are wrapped in [`Option`].
-    fn into_in_options(self) -> Self::InOptions;
-}
-
-/// A tuple with element types that all have the lifetime `'static`.
-pub trait WithAllElemLtStatic: Tuple + sealed::Sealed
-{
-    /// Returns the element at the given index.
-    fn get_mut<Element: 'static>(&mut self, index: usize) -> Option<&mut Element>;
-}
-
-/// Using the type system, reduces the elements of a tuple to a single one. Each element
-/// determines itself how it is handled.
-pub trait Reduce<Operation>
-{
-    type Out;
-}
-
-pub trait ReduceElement<Accumulator, Operation>
-{
-    type Return;
-}
-
-macro_rules! tuple_reduce_elem_tuple {
-    (overflow) => {
-        ()
-    };
-
-    ($index: tt) => {
-        paste! {
-            [<Elem $index>]::Return
-        }
-    };
-}
-
-macro_rules! elem_type_by_index {
-    (overflow) => {
-        ()
-    };
-
-    ($index: tt) => {
-        paste! {
-            [<Elem $index>]
-        }
-    };
-}
-
-macro_rules! elem_by_index {
-    (overflow) => {
-        ()
-    };
-
-    ($index: tt, $self: ident) => {
-        $self.$index
-    };
-}
-
-macro_rules! all_except_last {
-    (start $($rest: tt)*) => {
-        all_except_last!(@[] $($rest)*)
-    };
-
-    (@[$($included_elem: ident,)*] $elem: ident $($rest: tt)+) => {
-        all_except_last!(@[$($included_elem,)* $elem,] $($rest)*)
-    };
-
-    (@[$($included_elem: expr,)*] ($elem: expr) $($rest: tt)+) => {
-        all_except_last!(@[$($included_elem,)* $elem,] $($rest)*)
-    };
-
-    (@[$($included_elem: ident,)*] $elem: ident) => {
-        ($($included_elem,)*)
-    };
-
-    (@[$($included_elem: expr,)*] $elem: expr) => {
-        ($($included_elem,)*)
-    };
-
-    (@[]) => {
-        ()
-    };
-}
-
-macro_rules! impl_tuple_traits {
-    ($cnt: tt) => {
-        seq!(I in 0..$cnt {
-            impl<#(Elem~I,)*> Tuple for (#(Elem~I,)*)
-            {
-                type WithElementAtEnd<NewElem> = (#(Elem~I,)* NewElem,);
-
-                type WithoutLastElement = all_except_last!(start #(Elem~I)*);
-
-                type LastElement = sub!($cnt - 1, elem_type_by_index);
-
-                type InOptions = (#(Option<Elem~I>,)*);
-
-                fn pop_last(self) -> (Self::WithoutLastElement, Self::LastElement)
-                {
-                    (
-                        all_except_last!(start #((self.I))*),
-                        sub!($cnt - 1, elem_by_index, (self))
-                    )
-                }
-
-                fn into_in_options(self) -> Self::InOptions
-                {
-                    #![allow(clippy::unused_unit)]
-                    (#(Some(self.I),)*)
-                }
-            }
-
-            impl<#(Elem~I: 'static,)*> WithAllElemLtStatic for (#(Elem~I,)*)
-            {
-                fn get_mut<Element: 'static>(&mut self, index: usize) -> Option<&mut Element>
-                {
-                    match index {
-                        #(
-                            I => {
-                                assert!(TypeId::of::<Element>() == TypeId::of::<Elem~I>());
-
-                                // SAFETY: It is checked above that the type is correct
-                                Some(unsafe { &mut *(&raw mut self.I).cast::<Element>() })
-                            }
-                        )*
-                        _ => None
-                    }
-                }
-            }
-
-            impl<#(Elem~I,)*> sealed::Sealed for (#(Elem~I,)*)
-            {
-            }
-
-            paste! {
-                impl<Operation, #(Elem~I,)*> Reduce<Operation> for (#(Elem~I,)*)
-                where
-                    #(
-                        Elem~I: ReduceElement<
-                            sub!(I - 1, tuple_reduce_elem_tuple), Operation
-                        >,
-                    )*
-                {
-                    type Out = sub!($cnt - 1, tuple_reduce_elem_tuple);
-                }
-            }
-        });
-    };
-}
-
-seq!(N in 0..16 {
-    impl_tuple_traits!(N);
-});
-
-seq!(I in 0..16 {
-    impl<#(Elem~I,)*> Tuple for (#(Elem~I,)*)
-    {
-        type WithElementAtEnd<NewElem> = ();
-
-        type WithoutLastElement = all_except_last!(start #(Elem~I)*);
-
-        type LastElement = Elem15;
-
-        type InOptions = (#(Option<Elem~I>,)*);
-
-        fn pop_last(self) -> (Self::WithoutLastElement, Self::LastElement)
-        {
-            (
-                all_except_last!(start #((self.I))*),
-                self.15
-            )
-        }
-
-        fn into_in_options(self) -> Self::InOptions
-        {
-            #![allow(clippy::unused_unit)]
-            (#(Some(self.I),)*)
-        }
-    }
-
-    impl<#(Elem~I: 'static,)*> WithAllElemLtStatic for (#(Elem~I,)*)
-    {
-        fn get_mut<Element: 'static>(&mut self, index: usize) -> Option<&mut Element>
-        {
-            match index {
-                #(
-                    I => {
-                        assert!(TypeId::of::<Element>() == TypeId::of::<Elem~I>());
-
-                        // SAFETY: It is checked above that the type is correct
-                        Some(unsafe { &mut *(&raw mut self.I).cast::<Element>() })
-                    }
-                )*
-                _ => None
-            }
-        }
-    }
-
-    impl<#(Elem~I,)*> sealed::Sealed for (#(Elem~I,)*)
-    {
-    }
-});
-
-mod sealed
-{
-    pub trait Sealed {}
-}
diff --git a/ecs/src/uid.rs b/ecs/src/uid.rs
deleted file mode 100644
index bb393a1..0000000
--- a/ecs/src/uid.rs
+++ /dev/null
@@ -1,261 +0,0 @@
-use std::fmt::{Debug, Display, Formatter};
-use std::mem::transmute;
-use std::sync::atomic::{AtomicU32, Ordering};
-
-use seq_macro::seq;
-
-use crate::component::Component;
-use crate::util::{gen_mask_64, Array, BitMask, NumberExt};
-
-static NEXT: AtomicU32 = AtomicU32::new(Uid::FIRST_UNIQUE_ID);
-
-static WILDCARD_ID: u32 = 1;
-
-const ID_BITS: BitMask<u64> = BitMask::new(gen_mask_64!(32..=63));
-const RELATION_BITS: BitMask<u64> = BitMask::new(gen_mask_64!(6..=31));
-const KIND_BITS: BitMask<u64> = BitMask::new(gen_mask_64!(0..=1));
-
-#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
-#[repr(u8)]
-pub enum Kind
-{
-    Pair = 3,
-    Entity = 2,
-    Component = 1,
-}
-
-/// A unique identifier.
-#[derive(Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
-pub struct Uid
-{
-    inner: u64,
-}
-
-impl Uid
-{
-    /// The id part of the first unique `Uid`. The ids `0..Uid::FIRST_UNIQUE_ID` are
-    /// reserved.
-    pub const FIRST_UNIQUE_ID: u32 = 5;
-
-    /// Returns a new unique entity/component ID.
-    pub fn new_unique(kind: Kind) -> Self
-    {
-        let id = NEXT.fetch_add(1, Ordering::Relaxed);
-
-        Self {
-            inner: ID_BITS.field_prep(u64::from(id)) | KIND_BITS.field_prep(kind as u64),
-        }
-    }
-
-    #[must_use]
-    pub fn wildcard() -> Self
-    {
-        Self {
-            inner: ID_BITS.field_prep(u64::from(WILDCARD_ID))
-                | KIND_BITS.field_prep(Kind::Component as u64),
-        }
-    }
-
-    /// Returns a new pair UID.
-    ///
-    /// # Panics
-    /// Will panic if either the given relation or target is a pair UID.
-    #[must_use]
-    pub fn new_pair(params: &PairParams) -> Self
-    {
-        assert_ne!(
-            params.relation.kind(),
-            Kind::Pair,
-            "Pair relation cannot be a pair"
-        );
-
-        assert_ne!(
-            params.target.kind(),
-            Kind::Pair,
-            "Pair target cannot be a pair"
-        );
-
-        Self {
-            inner: ID_BITS.field_prep(u64::from(params.target.id()))
-                | RELATION_BITS.field_prep(u64::from(params.relation.id()))
-                | KIND_BITS.field_prep(Kind::Pair as u64),
-        }
-    }
-
-    #[must_use]
-    pub fn id(&self) -> u32
-    {
-        let Ok(id) = u32::try_from(self.inner.field_get(ID_BITS)) else {
-            unreachable!("Uid id does not fit in u32");
-        };
-
-        id
-    }
-
-    #[must_use]
-    pub fn kind(&self) -> Kind
-    {
-        let Ok(kind) = u8::try_from(self.inner.field_get(KIND_BITS)) else {
-            unreachable!("Uid kind does not fit in u8");
-        };
-
-        // SAFETY: The kind bits cannot be invalid since they are set using the Kind enum
-        // in the new_unique function
-        unsafe { transmute::<u8, Kind>(kind) }
-    }
-
-    /// If this `Uid` is a pair, returns the relation as a component `Uid`.
-    ///
-    /// # Panics
-    /// Will panic if this `Uid` is not a pair.
-    #[must_use]
-    pub fn relation_component(&self) -> Self
-    {
-        assert_eq!(self.kind(), Kind::Pair, "Uid is not a pair");
-
-        Self {
-            inner: ID_BITS.field_prep(u64::from(self.relation()))
-                | KIND_BITS.field_prep(Kind::Component as u64),
-        }
-    }
-
-    #[must_use]
-    pub fn has_same_relation_as(&self, other: Self) -> bool
-    {
-        self.relation() == other.relation()
-    }
-
-    /// If this `Uid` is a pair, returns the relation as a entity `Uid`.
-    ///
-    /// # Panics
-    /// Will panic if this `Uid` is not a pair.
-    #[must_use]
-    pub fn relation_entity(&self) -> Self
-    {
-        assert_eq!(self.kind(), Kind::Pair, "Uid is not a pair");
-
-        Self {
-            inner: ID_BITS.field_prep(u64::from(self.relation()))
-                | KIND_BITS.field_prep(Kind::Entity as u64),
-        }
-    }
-
-    /// If this `Uid` is a pair, returns the target as a component `Uid`.
-    ///
-    /// # Panics
-    /// Will panic if this `Uid` is not a pair.
-    #[must_use]
-    pub fn target_component(&self) -> Self
-    {
-        assert_eq!(self.kind(), Kind::Pair, "Uid is not a pair");
-
-        Self {
-            inner: ID_BITS.field_prep(u64::from(self.id()))
-                | KIND_BITS.field_prep(Kind::Component as u64),
-        }
-    }
-
-    /// If this `Uid` is a pair, returns the target as a entity `Uid`.
-    ///
-    /// # Panics
-    /// Will panic if this `Uid` is not a pair.
-    #[must_use]
-    pub fn target_entity(&self) -> Self
-    {
-        assert_eq!(self.kind(), Kind::Pair, "Uid is not a pair");
-
-        Self {
-            inner: ID_BITS.field_prep(u64::from(self.id()))
-                | KIND_BITS.field_prep(Kind::Entity as u64),
-        }
-    }
-
-    fn relation(self) -> u32
-    {
-        let Ok(relation) = u32::try_from(self.inner.field_get(RELATION_BITS)) else {
-            unreachable!("Uid relation does not fit in u32");
-        };
-
-        relation
-    }
-}
-
-impl Debug for Uid
-{
-    fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result
-    {
-        formatter
-            .debug_struct("Uid")
-            .field("id", &self.id())
-            .field("kind", &self.kind())
-            .finish_non_exhaustive()
-    }
-}
-
-impl Display for Uid
-{
-    fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result
-    {
-        if self.kind() == Kind::Pair {
-            return write!(
-                formatter,
-                "({}, {})",
-                self.relation(),
-                self.target_component()
-            );
-        }
-
-        if *self == Uid::wildcard() {
-            return write!(formatter, "*");
-        }
-
-        write!(formatter, "{}", self.id())
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct PairParams
-{
-    pub relation: Uid,
-    pub target: Uid,
-}
-
-pub trait With
-{
-    fn uid() -> Uid;
-}
-
-impl<ComponentT: Component> With for ComponentT
-{
-    fn uid() -> Uid
-    {
-        Self::id()
-    }
-}
-
-pub trait WithUidTuple
-{
-    type UidsArray: Array<Uid>;
-
-    fn uids() -> Self::UidsArray;
-}
-
-macro_rules! impl_with_uid_tuple {
-    ($c: tt) => {
-        seq!(I in 0..=$c {
-            impl<#(WithUid~I: With,)*> WithUidTuple for (#(WithUid~I,)*)
-            {
-                type UidsArray = [Uid; $c + 1];
-
-                fn uids() -> Self::UidsArray
-                {
-                    [#(WithUid~I::uid(),)*]
-                }
-            }
-        });
-    };
-}
-
-seq!(C in 0..=16 {
-    impl_with_uid_tuple!(C);
-});
diff --git a/ecs/src/util.rs b/ecs/src/util.rs
deleted file mode 100644
index 27e9748..0000000
--- a/ecs/src/util.rs
+++ /dev/null
@@ -1,415 +0,0 @@
-use std::hash::Hash;
-use std::mem::transmute;
-use std::ops::{BitAnd, Deref};
-
-use hashbrown::HashMap;
-
-pub(crate) mod array_vec;
-
-pub trait VecExt<Item>
-{
-    fn insert_at_part_pt_by_key<Key>(
-        &mut self,
-        item: Item,
-        func: impl FnMut(&Item) -> &Key,
-    ) where
-        Key: Ord;
-}
-
-impl<Item> VecExt<Item> for Vec<Item>
-{
-    fn insert_at_part_pt_by_key<Key>(
-        &mut self,
-        item: Item,
-        mut func: impl FnMut(&Item) -> &Key,
-    ) where
-        Key: Ord,
-    {
-        let key = func(&item);
-
-        let insert_index = self.partition_point(|other_item| func(other_item) <= key);
-
-        self.insert(insert_index, item);
-    }
-}
-
-pub trait StreamingIterator
-{
-    type Item<'a>
-    where
-        Self: 'a;
-
-    fn streaming_next(&mut self) -> Option<Self::Item<'_>>;
-
-    fn streaming_map<NewItem, Func>(self, func: Func) -> StreamingMap<Self, Func>
-    where
-        Self: Sized,
-        Func: FnMut(Self::Item<'_>) -> NewItem,
-    {
-        StreamingMap { iter: self, func }
-    }
-
-    fn streaming_find<'this, Predicate>(
-        &'this mut self,
-        mut predicate: Predicate,
-    ) -> Option<Self::Item<'this>>
-    where
-        Self: Sized,
-        Predicate: FnMut(&Self::Item<'this>) -> bool,
-    {
-        while let Some(item) = unsafe {
-            transmute::<Option<Self::Item<'_>>, Option<Self::Item<'_>>>(
-                self.streaming_next(),
-            )
-        } {
-            if predicate(&item) {
-                return Some(item);
-            }
-        }
-
-        None
-    }
-}
-
-pub struct StreamingMap<Iter, Func>
-{
-    iter: Iter,
-    func: Func,
-}
-
-impl<Iter, Func, Item> StreamingIterator for StreamingMap<Iter, Func>
-where
-    Iter: StreamingIterator,
-    Func: FnMut(Iter::Item<'_>) -> Item,
-{
-    type Item<'a>
-        = Item
-    where
-        Iter: 'a,
-        Func: 'a;
-
-    fn streaming_next(&mut self) -> Option<Self::Item<'_>>
-    {
-        Some((self.func)(self.iter.streaming_next()?))
-    }
-}
-
-#[derive(Debug)]
-pub enum BorrowedOrOwned<'a, Value>
-{
-    Borrowned(&'a Value),
-    Owned(Value),
-}
-
-impl<Value> Deref for BorrowedOrOwned<'_, Value>
-{
-    type Target = Value;
-
-    fn deref(&self) -> &Self::Target
-    {
-        match self {
-            Self::Borrowned(value) => value,
-            Self::Owned(value) => value,
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub enum Either<A, B>
-{
-    A(A),
-    B(B),
-}
-
-impl<A, B> Iterator for Either<A, B>
-where
-    A: Iterator,
-    B: Iterator<Item = A::Item>,
-{
-    type Item = A::Item;
-
-    fn next(&mut self) -> Option<Self::Item>
-    {
-        match self {
-            Self::A(a) => a.next(),
-            Self::B(b) => b.next(),
-        }
-    }
-}
-
-pub trait HashMapExt<Key, Value>
-{
-    /// Returns true if the keys are a subset of another [`HashMap`]'s keys, i.e., `other`
-    /// contains at least all the keys in `self`.
-    fn keys_is_subset(&self, other: &Self) -> bool;
-
-    /// Returns true if the keys are a superset of another [`HashMap`]'s keys, i.e.,
-    /// `self` contains at least all the keys in `other`.
-    fn keys_is_superset(&self, other: &Self) -> bool;
-}
-
-impl<Key, Value> HashMapExt<Key, Value> for HashMap<Key, Value>
-where
-    Key: Eq + Hash,
-{
-    fn keys_is_subset(&self, other: &Self) -> bool
-    {
-        if self.len() <= other.len() {
-            self.keys().all(|key| other.contains_key(key))
-        } else {
-            false
-        }
-    }
-
-    fn keys_is_superset(&self, other: &Self) -> bool
-    {
-        other.keys_is_subset(self)
-    }
-}
-
-pub trait Array<Item>:
-    AsRef<[Item]>
-    + AsMut<[Item]>
-    + IntoIterator<Item = Item>
-    + Into<Vec<Item>>
-    + Sortable<Item = Item>
-    + sealed::Sealed
-{
-}
-
-impl<Item, const CNT: usize> Array<Item> for [Item; CNT] {}
-
-impl<Item, const CNT: usize> sealed::Sealed for [Item; CNT] {}
-
-pub trait Sortable
-{
-    type Item;
-
-    fn sort_by_key_b<Key, Func>(&mut self, func: Func)
-    where
-        Func: FnMut(&Self::Item) -> Key,
-        Key: Ord;
-}
-
-impl<Item> Sortable for [Item]
-{
-    type Item = Item;
-
-    fn sort_by_key_b<Key, Func>(&mut self, func: Func)
-    where
-        Func: FnMut(&Self::Item) -> Key,
-        Key: Ord,
-    {
-        self.sort_by_key(func);
-    }
-}
-
-impl<Item, const LENGTH: usize> Sortable for [Item; LENGTH]
-{
-    type Item = Item;
-
-    fn sort_by_key_b<Key, Func>(&mut self, func: Func)
-    where
-        Func: FnMut(&Self::Item) -> Key,
-        Key: Ord,
-    {
-        self.sort_by_key(func);
-    }
-}
-
-impl<Item> Sortable for Vec<Item>
-{
-    type Item = Item;
-
-    fn sort_by_key_b<Key, Func>(&mut self, func: Func)
-    where
-        Func: FnMut(&Self::Item) -> Key,
-        Key: Ord,
-    {
-        self.sort_by_key(func);
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct BitMask<Value>
-{
-    mask: Value,
-}
-
-impl BitMask<u64>
-{
-    #[must_use]
-    pub const fn new(mask: u64) -> Self
-    {
-        Self { mask }
-    }
-
-    #[must_use]
-    pub const fn value(self) -> u64
-    {
-        self.mask
-    }
-
-    /// Prepares a bitfield value in the range of bits specified by this `BitMask`.
-    #[must_use]
-    pub const fn field_prep(self, field_value: u64) -> u64
-    {
-        debug_assert!(field_value < 1 << self.mask.count_ones());
-
-        ((field_value) << self.mask.trailing_zeros()) & (self.mask)
-    }
-}
-
-impl BitAnd<u64> for BitMask<u64>
-{
-    type Output = u64;
-
-    fn bitand(self, rhs: u64) -> Self::Output
-    {
-        self.mask & rhs
-    }
-}
-
-pub trait NumberExt: Sized
-{
-    /// Returns a range of bits (field) specified by the provided [`BitMask`].
-    #[must_use]
-    fn field_get(self, field_mask: BitMask<Self>) -> Self;
-}
-
-impl NumberExt for u64
-{
-    fn field_get(self, field_mask: BitMask<Self>) -> Self
-    {
-        (field_mask & self) >> field_mask.value().trailing_zeros()
-    }
-}
-
-macro_rules! gen_mask_64 {
-    ($low: literal..=$high: literal) => {
-        const {
-            if $high <= $low {
-                panic!("High bit index cannot be less than or equal to low bit index");
-            }
-
-            (((!0u64) - (1u64 << ($low)) + 1)
-                & (!0u64 >> (u64::BITS as u64 - 1 - ($high))))
-        }
-    };
-}
-
-pub(crate) use gen_mask_64;
-
-macro_rules! impl_multiple {
-    (
-        $type: ident,
-        ($(
-            impl$(<$($generic: tt$(: $bound: ident)?),*>)?
-            _<$($lt_param: lifetime),*><$($type_param: ty),*>
-            $(($($extra_cb_arg: expr),*))?
-        ),*)
-        cb=(
-            type_params=($($ty_param_matcher: ident),*)
-            $(, $($extra_matcher: ident),+)?
-        ) => {
-            $($item_tt: tt)*
-        }
-    ) => {
-        const _: () = {
-            $crate::util::impl_multiple!(
-                @(make_gen_item_macro)
-                _gen_multiple_impl_item,
-                ($($ty_param_matcher),*),
-                ($($($extra_matcher),+)?),
-                ($($item_tt)*)
-            );
-
-            $(
-                impl $(<$($generic$(: $bound)?,)*>)? $type<$($lt_param,)* $($type_param),*>
-                {
-                    _gen_multiple_impl_item!(
-                        type_params=($($type_param),*),
-                        $($($extra_cb_arg),*)?
-                    );
-                }
-            )*
-        };
-    };
-
-    (
-        @(make_gen_item_macro)
-        $name: ident,
-        ($($ty_param_matcher: ident),*),
-        ($($extra_matcher: ident),*),
-        ($($transcriber: tt)*)
-    ) => {
-        $crate::util::impl_multiple!(
-            @(make_gen_item_macro)
-            ($),
-            $name,
-            ($($ty_param_matcher),*),
-            ($($extra_matcher),*),
-            ($($transcriber)*)
-        );
-    };
-
-    (
-        @(make_gen_item_macro)
-        ($dollar: tt),
-        $name: ident,
-        ($($ty_param_matcher: ident),*),
-        ($($extra_matcher: ident),*),
-        ($($transcriber: tt)*)
-    ) => {
-        $crate::util::impl_multiple!(
-            @(make_gen_item_macro)
-            $name,
-            (
-                type_params=($($dollar$ty_param_matcher: ty),*),
-                $($dollar$extra_matcher: expr),*
-            ) => {
-                $($transcriber)*
-            }
-        );
-    };
-
-    (@(make_gen_item_macro) $name: ident, $($rule: tt)*) => {
-        macro_rules! $name {
-            $($rule)*
-        }
-    };
-}
-
-pub(crate) use impl_multiple;
-
-mod sealed
-{
-    pub trait Sealed {}
-}
-
-#[cfg(test)]
-mod tests
-{
-
-    use super::BitMask;
-    use crate::util::NumberExt;
-
-    #[test]
-    fn field_get_works()
-    {
-        assert_eq!(0b11011u64.field_get(BitMask::new(0b11100)), 0b00110);
-    }
-
-    #[test]
-    fn bitmask_field_prep_works()
-    {
-        assert_eq!(BitMask::new(0b11000).field_prep(3), 0b11000);
-    }
-
-    #[test]
-    #[should_panic]
-    fn bitmask_field_prep_too_large_value_panics()
-    {
-        let _ = BitMask::new(0b001110).field_prep(9);
-    }
-}
diff --git a/ecs/src/util/array_vec.rs b/ecs/src/util/array_vec.rs
deleted file mode 100644
index 5d0aac9..0000000
--- a/ecs/src/util/array_vec.rs
+++ /dev/null
@@ -1,131 +0,0 @@
-use std::mem::MaybeUninit;
-use std::ops::{Deref, DerefMut};
-
-#[derive(Debug)]
-pub struct ArrayVec<Item, const CAPACITY: usize>
-{
-    items: [MaybeUninit<Item>; CAPACITY],
-    len: usize,
-}
-
-impl<Item, const CAPACITY: usize> ArrayVec<Item, CAPACITY>
-{
-    #[inline]
-    #[must_use]
-    pub fn len(&self) -> usize
-    {
-        self.len
-    }
-
-    #[inline]
-    #[must_use]
-    pub fn is_empty(&self) -> bool
-    {
-        self.len == 0
-    }
-
-    pub fn push(&mut self, item: Item)
-    {
-        assert!(self.len < CAPACITY);
-
-        self.items[self.len].write(item);
-
-        self.len += 1;
-    }
-
-    pub fn insert(&mut self, index: usize, item: Item)
-    {
-        assert!(index <= self.len);
-        assert!(self.len < CAPACITY);
-
-        if index == self.len {
-            self.push(item);
-            return;
-        }
-
-        unsafe {
-            std::ptr::copy(
-                &raw const self.items[index],
-                &raw mut self.items[index + 1],
-                self.len - index,
-            );
-        }
-
-        self.items[index].write(item);
-
-        self.len += 1;
-    }
-}
-
-impl<Item, const CAPACITY: usize> Extend<Item> for ArrayVec<Item, CAPACITY>
-{
-    fn extend<IntoIter: IntoIterator<Item = Item>>(&mut self, iter: IntoIter)
-    {
-        for item in iter {
-            self.push(item);
-        }
-    }
-}
-
-impl<Item, const CAPACITY: usize> AsRef<[Item]> for ArrayVec<Item, CAPACITY>
-{
-    fn as_ref(&self) -> &[Item]
-    {
-        let ptr = &raw const self.items[..self.len];
-
-        unsafe { &*(ptr as *const [Item]) }
-    }
-}
-
-impl<Item, const CAPACITY: usize> AsMut<[Item]> for ArrayVec<Item, CAPACITY>
-{
-    fn as_mut(&mut self) -> &mut [Item]
-    {
-        let ptr = &raw mut self.items[..self.len];
-
-        unsafe { &mut *(ptr as *mut [Item]) }
-    }
-}
-
-impl<Item, const CAPACITY: usize> Deref for ArrayVec<Item, CAPACITY>
-{
-    type Target = [Item];
-
-    fn deref(&self) -> &Self::Target
-    {
-        self.as_ref()
-    }
-}
-
-impl<Item, const CAPACITY: usize> DerefMut for ArrayVec<Item, CAPACITY>
-{
-    fn deref_mut(&mut self) -> &mut Self::Target
-    {
-        self.as_mut()
-    }
-}
-
-impl<Item, const CAPACITY: usize> Default for ArrayVec<Item, CAPACITY>
-{
-    fn default() -> Self
-    {
-        Self {
-            items: [const { MaybeUninit::uninit() }; CAPACITY],
-            len: 0,
-        }
-    }
-}
-
-impl<Item, const CAPACITY: usize> Drop for ArrayVec<Item, CAPACITY>
-{
-    fn drop(&mut self)
-    {
-        for item in &mut self.items[..self.len] {
-            // SAFETY: The items from index 0 to the length index will always be
-            // initialized and satisfy all the invariants of the Item type.
-            unsafe {
-                item.assume_init_drop();
-            }
-        }
-    }
-}
diff --git a/ecs/tests/phase.rs b/ecs/tests/phase.rs
deleted file mode 100644
index af2646b..0000000
--- a/ecs/tests/phase.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-use std::sync::atomic::{AtomicUsize, Ordering};
-
-use ecs::component::local::Local;
-use ecs::phase::UPDATE;
-use ecs::system::Into;
-use ecs::system::initializable::Initializable;
-use ecs::{Component, World};
-
-#[derive(Component)]
-struct Thing;
-
-#[test]
-fn system_run_order_correct_when_one_has_local_comp()
-{
-    static COUNTER: AtomicUsize = AtomicUsize::new(0);
-
-    fn first_system(_thing: Local<Thing>)
-    {
-        assert_eq!(COUNTER.fetch_add(1, Ordering::Relaxed), 0);
-    }
-
-    fn second_system()
-    {
-        assert_eq!(COUNTER.fetch_add(1, Ordering::Relaxed), 1);
-    }
-
-    let mut world = World::new();
-
-    world.register_system(*UPDATE, first_system.into_system().initialize((Thing,)));
-
-    world.register_system(*UPDATE, second_system);
-
-    world.step();
-
-    assert_eq!(COUNTER.load(Ordering::Relaxed), 2);
-}
diff --git a/ecs/tests/query.rs b/ecs/tests/query.rs
deleted file mode 100644
index 7b218e3..0000000
--- a/ecs/tests/query.rs
+++ /dev/null
@@ -1,413 +0,0 @@
-use ecs::component::Component;
-use ecs::pair::{Pair, Wildcard};
-use ecs::query::term::Without;
-use ecs::query::{
-    TermWithFieldTuple as QueryTermWithFieldTuple,
-    TermWithoutFieldTuple as QueryTermWithoutFieldTuple,
-};
-use ecs::uid::Uid;
-use ecs::{Component, Query, World};
-use parking_lot::{Mutex, Once};
-
-pub static SETUP: Once = Once::new();
-
-pub static TEST_LOCK: Mutex<()> = Mutex::new(());
-
-#[derive(Component)]
-struct A;
-
-#[derive(Component)]
-struct B;
-
-#[derive(Component)]
-struct C;
-
-#[derive(Component)]
-struct D;
-
-#[derive(Component)]
-struct E;
-
-#[derive(Component)]
-struct F;
-
-#[derive(Component)]
-struct G;
-
-fn setup()
-{
-    SETUP.call_once_force(|_| {
-        assert_eq!(A::id().id(), Uid::FIRST_UNIQUE_ID);
-        assert_eq!(B::id().id(), Uid::FIRST_UNIQUE_ID + 1);
-        assert_eq!(C::id().id(), Uid::FIRST_UNIQUE_ID + 2);
-        assert_eq!(D::id().id(), Uid::FIRST_UNIQUE_ID + 3);
-        assert_eq!(E::id().id(), Uid::FIRST_UNIQUE_ID + 4);
-        assert_eq!(F::id().id(), Uid::FIRST_UNIQUE_ID + 5);
-        assert_eq!(G::id().id(), Uid::FIRST_UNIQUE_ID + 6);
-    });
-}
-
-fn assert_query_finds_ents<QueryFieldTerms, QueryFieldlessTerms>(
-    query: Query<'_, QueryFieldTerms, QueryFieldlessTerms>,
-    mut expected_ent_ids: Vec<Uid>,
-) where
-    QueryFieldTerms: QueryTermWithFieldTuple,
-    QueryFieldlessTerms: QueryTermWithoutFieldTuple,
-{
-    assert!(
-        query.iter_with_euids().all(|(ent_id, _)| {
-            let Some(index) = expected_ent_ids
-                .iter()
-                .position(|expected_id| *expected_id == ent_id)
-            else {
-                return false;
-            };
-
-            expected_ent_ids.remove(index);
-
-            true
-        }),
-        "Unexpected entity was found. Expected entities left: {expected_ent_ids:?}"
-    );
-
-    assert_eq!(
-        expected_ent_ids.len(),
-        0,
-        concat!(
-            "Not all entities expected to be found was found. ",
-            "Expected entities left: {:?}"
-        ),
-        expected_ent_ids
-    );
-}
-
-#[test]
-fn query_archetype_exists_with_edges_to_next_archetypes()
-{
-    setup();
-
-    let _test_lock = TEST_LOCK.lock();
-
-    let mut world = World::new();
-
-    let ent_1_id = world.create_entity((A, B, C));
-    let ent_2_id = world.create_entity((A, B, C, D, E));
-    let ent_3_id = world.create_entity((A, B, C, E));
-    let ent_4_id = world.create_entity((A, B, C, G, F));
-
-    assert_query_finds_ents(
-        world.query::<(&A, &B, &C), ()>(),
-        vec![ent_1_id, ent_2_id, ent_3_id, ent_4_id],
-    );
-}
-
-#[test]
-fn query_archetype_exists_with_2_comps_diff_to_next_archetype()
-{
-    setup();
-
-    let _test_lock = TEST_LOCK.lock();
-
-    let mut world = World::new();
-
-    let ent_1_id = world.create_entity((A, B, C, D, F));
-
-    let ent_2_id = world.create_entity((A, B, F));
-
-    assert_query_finds_ents(world.query::<(&A, &B, &F), ()>(), vec![ent_1_id, ent_2_id]);
-}
-
-#[test]
-fn query_archetype_exists_with_2_comps_diff_to_next_archetype_rev()
-{
-    setup();
-
-    let _test_lock = TEST_LOCK.lock();
-
-    let mut world = World::new();
-
-    let ent_1_id = world.create_entity((A, B, F));
-
-    let ent_2_id = world.create_entity((A, B, C, D, F));
-
-    assert_query_finds_ents(world.query::<(&A, &B, &F), ()>(), vec![ent_1_id, ent_2_id]);
-}
-
-#[test]
-fn query_archetype_exists_with_3_comps_diff_to_next_archetype()
-{
-    setup();
-
-    let _test_lock = TEST_LOCK.lock();
-
-    let mut world = World::new();
-
-    let ent_1_id = world.create_entity((A, B, C, D, E, F));
-
-    let ent_2_id = world.create_entity((A, B, F));
-
-    assert_query_finds_ents(world.query::<(&A, &B, &F), ()>(), vec![ent_1_id, ent_2_id]);
-}
-
-#[test]
-fn query_archetype_exists_with_3_comps_diff_to_next_archetype_rev()
-{
-    setup();
-
-    let _test_lock = TEST_LOCK.lock();
-
-    let mut world = World::new();
-
-    let ent_1_id = world.create_entity((A, B, F));
-
-    let ent_2_id = world.create_entity((A, B, C, D, E, F));
-
-    assert_query_finds_ents(world.query::<(&A, &B, &F), ()>(), vec![ent_1_id, ent_2_id]);
-}
-
-#[test]
-fn query_archetype_exists_with_4_comps_diff_to_next_archetype()
-{
-    setup();
-
-    let _test_lock = TEST_LOCK.lock();
-
-    let mut world = World::new();
-
-    let ent_1_id = world.create_entity((A, B, C, D, E, F, G));
-
-    let ent_2_id = world.create_entity((A, B, G));
-
-    assert_query_finds_ents(world.query::<(&A, &B, &G), ()>(), vec![ent_1_id, ent_2_id]);
-}
-
-#[test]
-fn query_archetype_exists_with_4_comps_diff_to_next_archetype_rev()
-{
-    setup();
-
-    let _test_lock = TEST_LOCK.lock();
-
-    let mut world = World::new();
-
-    let ent_1_id = world.create_entity((A, B, G));
-
-    let ent_2_id = world.create_entity((A, B, C, D, E, F, G));
-
-    assert_query_finds_ents(world.query::<(&A, &B, &G), ()>(), vec![ent_1_id, ent_2_id]);
-}
-
-#[test]
-fn query_archetype_exists_with_4_comps_diff_to_next_archetype_and_opt_comp()
-{
-    setup();
-
-    let _test_lock = TEST_LOCK.lock();
-
-    let mut world = World::new();
-
-    let ent_1_id = world.create_entity((A, B, C, D, E, F, G));
-
-    let ent_2_id = world.create_entity((A, B, G));
-
-    assert_query_finds_ents(
-        world.query::<(&A, Option<&E>, &G), ()>(),
-        vec![ent_1_id, ent_2_id],
-    );
-}
-
-#[test]
-fn query_archetype_nonexistant()
-{
-    setup();
-
-    let _test_lock = TEST_LOCK.lock();
-
-    let mut world = World::new();
-
-    world.create_entity((A, B, C));
-
-    let ent_2_id = world.create_entity((A, B, C, D, E));
-    let ent_3_id = world.create_entity((A, B, C, E));
-
-    world.create_entity((A, B, C, G, F));
-
-    assert_query_finds_ents(world.query::<(&A, &E), ()>(), vec![ent_2_id, ent_3_id]);
-}
-
-#[test]
-fn query_archetype_nonexistant_and_opt_comp()
-{
-    setup();
-
-    let _test_lock = TEST_LOCK.lock();
-
-    let mut world = World::new();
-
-    world.create_entity((A, B, C));
-    let ent_2_id = world.create_entity((A, B, C, D, E));
-    let ent_3_id = world.create_entity((A, B, C, E));
-    world.create_entity((A, B, C, G, F));
-
-    assert_query_finds_ents(
-        world.query::<(&A, &E, Option<&D>), ()>(),
-        vec![ent_2_id, ent_3_id],
-    );
-}
-
-#[test]
-fn query_without_comp_and_archetype_exists()
-{
-    setup();
-
-    let _test_lock = TEST_LOCK.lock();
-
-    let mut world = World::new();
-
-    let ent_1_id = world.create_entity((A, B, C));
-
-    world.create_entity((A, B, C, E));
-    world.create_entity((A, B, C, F, E));
-
-    let ent_2_id = world.create_entity((A, B, C, G));
-    let ent_3_id = world.create_entity((A, B, C, G, F));
-
-    assert_query_finds_ents(
-        world.query::<(&A, &B, &C), (Without<E>,)>(),
-        vec![ent_1_id, ent_2_id, ent_3_id],
-    );
-}
-
-#[test]
-fn query_without_required_comp_and_archetype_exists()
-{
-    setup();
-
-    let _test_lock = TEST_LOCK.lock();
-
-    let mut world = World::new();
-
-    world.create_entity((A, B, C));
-
-    world.create_entity((A, B, C, E));
-    world.create_entity((A, B, C, F, E));
-
-    world.create_entity((A, B, C, G));
-    world.create_entity((A, B, C, G, F));
-
-    assert_query_finds_ents(world.query::<(&A, &B), (Without<B>,)>(), vec![]);
-}
-
-#[test]
-fn query_without_comp_and_archetype_nonexistant()
-{
-    setup();
-
-    let _test_lock = TEST_LOCK.lock();
-
-    let mut world = World::new();
-
-    world.create_entity((A, B, C));
-
-    let ent_1_id = world.create_entity((A, B, C, E));
-
-    world.create_entity((A, B, C, F, E));
-
-    let ent_2_id = world.create_entity((A, B, C, G, E));
-    world.create_entity((A, B, C, G, F, E));
-
-    assert_query_finds_ents(
-        world.query::<(&A, &E), (Without<F>,)>(),
-        vec![ent_1_id, ent_2_id],
-    );
-}
-
-#[test]
-fn query_with_wildcard_target_pair()
-{
-    setup();
-
-    let _test_lock = TEST_LOCK.lock();
-
-    let mut world = World::new();
-
-    let ent_1_id = world.create_entity((A, C));
-
-    world.create_entity((B,));
-
-    let ent_2_id = world.create_entity((
-        B,
-        Pair::builder().relation::<G>().target_id(ent_1_id).build(),
-    ));
-
-    world.create_entity((
-        B,
-        Pair::builder().relation::<F>().target_id(ent_1_id).build(),
-    ));
-    world.create_entity((
-        B,
-        A,
-        C,
-        Pair::builder().relation::<F>().target_id(ent_1_id).build(),
-    ));
-
-    let ent_3_id = world.create_entity((
-        B,
-        Pair::builder().relation::<G>().target_id(ent_2_id).build(),
-    ));
-
-    let ent_4_id = world.create_entity((
-        B,
-        E,
-        Pair::builder().relation::<G>().target_as_data(D).build(),
-    ));
-
-    assert_query_finds_ents(
-        world.query::<(&B, Pair<G, Wildcard>), ()>(),
-        vec![ent_2_id, ent_3_id, ent_4_id],
-    );
-}
-
-#[test]
-fn query_with_component_target_pair()
-{
-    setup();
-
-    let _test_lock = TEST_LOCK.lock();
-
-    let mut world = World::new();
-
-    let ent_1_id = world.create_entity((A, C));
-
-    world.create_entity((B,));
-
-    world.create_entity((
-        B,
-        Pair::builder().relation::<G>().target_id(ent_1_id).build(),
-    ));
-
-    world.create_entity((
-        B,
-        Pair::builder().relation::<F>().target_id(ent_1_id).build(),
-    ));
-    world.create_entity((
-        B,
-        A,
-        C,
-        Pair::builder().relation::<F>().target_id(ent_1_id).build(),
-    ));
-
-    let ent_2_id = world
-        .create_entity((B, Pair::builder().relation::<G>().target_as_data(F).build()));
-
-    let ent_3_id = world.create_entity((
-        B,
-        E,
-        Pair::builder().relation::<G>().target_as_data(F).build(),
-    ));
-
-    assert_query_finds_ents(
-        world.query::<(&B, Pair<G, &F>), ()>(),
-        vec![ent_2_id, ent_3_id],
-    );
-}