Migration writing pass 4 (#2088)

BD103 · JaySpruce · alice-i-cecile · web-flow · commit 4a084e114d4d · 2025-04-08T23:33:34.000Z
Co-authored-by: JaySpruce &lt;jsprucebruce@gmail.com&gt;
Co-authored-by: Alice Cecile &lt;alice.i.cecile@gmail.com&gt;
diff --git a/content/learn/migration-guides/0.15-to-0.16.md b/content/learn/migration-guides/0.15-to-0.16.md
@@ -12,6 +12,7 @@ This guide is currently for a __Release Candidate__ and is subject to change as
 
 The most important changes to be aware of this release are:
 
-- Bevy now prefers `Result`s over panicking, as applications can easily recover from `Result`s instead of crashing. As part of this decision, Bevy's error handling capabilities have been significantly improved. (Systems can easily return `Result`s and a new `BevyError` type has been introduced.) Additionally, several panicking functions have been switched to return a result (`Query::single()`) or have been deprecated completely (`Query::many()`).
+- Bevy has reworked its error handling to make it easier to handle `Result`s everywhere. As a result, `Query::single` and friends now return results, rather than panicking.
+- Bevy's ECS now has built-in one-to-many entity relationships. The existing parent-child hierarchy system has been modified to use these relationships, causing minor breaking changes in entity despawning behavior and how children are added / replaced for a parent entity.
 
 {{ migration_guides(version="0.16") }}
diff --git a/release-content/0.16/migration-guides/15519_Remove_petgraph_from_bevy_ecs.md b/release-content/0.16/migration-guides/15519_Remove_petgraph_from_bevy_ecs.md
@@ -1 +1,3 @@
-The `Dag::graph` method no longer returns a `petgraph` `DiGraph` and instead returns the new `DiGraph` type within `bevy_ecs`. Edge and node iteration methods are provided so conversion to the `petgraph` type should be trivial if required.
+Bevy's ECS no longer depends on the `petgraph` crate. As such, usage of `petgraph::graph::DiGraph` has been replaced with `bevy::ecs::schedule::graph::DiGraph`. This mainly affects code that uses the `Dag::graph()` method.
+
+If you require the `petgraph` version of `DiGraph`, you can manually construct it by iterating over all edges and nodes in Bevy's `DiGraph`.
diff --git a/release-content/0.16/migration-guides/16348_Remove_deprecated_component_reads_and_writes.md b/release-content/0.16/migration-guides/16348_Remove_deprecated_component_reads_and_writes.md
@@ -1,16 +1,18 @@
-The following methods (some removed in previous PRs) are now replaced by `Access::try_iter_component_access`:
+The following methods are now replaced by `Access::try_iter_component_access()`:
 
-- `Access::component_reads_and_writes`
-- `Access::component_reads`
-- `Access::component_writes`
+- `Access::component_reads_and_writes()`
+- `Access::component_reads()`
+- `Access::component_writes()`
 
-As `try_iter_component_access` returns a `Result`, you’ll now need to handle the failing case (e.g., `unwrap()`). There is currently a single failure mode, `UnboundedAccess`, which occurs when the `Access` is for all `Components` _except_ certain exclusions. Since this list is infinite, there is no meaningful way for `Access` to provide an iterator. Instead, get a list of components (e.g., from the `Components` structure) and iterate over that instead, filtering using `Access::has_component_read`, `Access::has_component_write`, etc.
+As `try_iter_component_access()` returns a `Result`, you’ll now need to handle the failing case (e.g. return early from a system). There is currently a single failure mode, `UnboundedAccess`, which occurs when the `Access` is for all `Components` _except_ certain exclusions. Since this list is infinite, there is no meaningful way for `Access` to provide an iterator. Instead, get a list of components (e.g. from the `Components` structure) and iterate over that instead, filtering using `Access::has_component_read()`, `Access::has_component_write()`, etc.
 
-Additionally, you’ll need to `filter_map` the accesses based on which method you’re attempting to replace:
+Additionally, you’ll need to `filter_map()` the accesses based on which method you’re attempting to replace:
 
-- `Access::component_reads_and_writes` -> `Exclusive(_) | Shared(_)`
-- `Access::component_reads` -> `Shared(_)`
-- `Access::component_writes` -> `Exclusive(_)`
+|0.15|0.16|
+|-|-|
+|`Access::component_reads_and_writes()`|`Exclusive(_) | Shared(_)`|
+|`Access::component_reads()`|`Shared(_)`|
+|`Access::component_writes()`|`Exclusive(_)`|
 
 To ease migration, please consider the below extension trait which you can include in your project:
 
@@ -74,4 +76,4 @@ impl<T: SparseSetIndex> AccessCompatibilityExt for Access<T> {
 }
 ```
 
-Please take note of the use of `expect(...)` in these methods. You should consider using these as a starting point for a more appropriate migration based on your specific needs.
+Please take note of the use of `expect()` in this code. You should consider using this as a starting point for a more appropriate migration based on your specific needs.
diff --git a/release-content/0.16/migration-guides/16460_Remove_flush_and_reserve_invalid_assuming_no_entities.md b/release-content/0.16/migration-guides/16460_Remove_flush_and_reserve_invalid_assuming_no_entities.md
@@ -1 +1 @@
-- exchange `Entities::flush_and_reserve_invalid_assuming_no_entities` for `reserve` and `flush_as_invalid` and notify us if that’s insufficient
+`Entities::flush_and_reserve_invalid_assuming_no_entities()` was a specialized method primarily used in 0.14 and earlier's rendering world design. With 0.15, `flush_and_reserve_invalid_assuming_no_entities()` went unused, so it now has been removed. If you previously required this method, you should switch to calling `Entities::reserve_entities()` and `Entities::flush_as_invalid()`.
diff --git a/release-content/0.16/migration-guides/16853_Remove_deprecated_ECS_items.md b/release-content/0.16/migration-guides/16853_Remove_deprecated_ECS_items.md
@@ -1 +1,14 @@
-- The following deprecated items were removed: `Events::get_reader`, `Events::get_reader_current`, `ManualEventReader`, `Condition::and_then`, `Condition::or_else`, `World::,many_entities`, `World::many_entities_mut`, `World::get_many_entities`, `World::get_many_entities_dynamic`, `World::get_many_entities_mut`, `World::get_many_entities_dynamic_mut`, `World::get_many_entities_from_set_mut`
+The following `bevy::ecs` items that were deprecated in 0.15 have been removed:
+
+- `Events::get_reader()`
+- `Events::get_reader_current()`
+- `ManualEventReader`
+- `Condition::and_then()`
+- `Condition::or_else()`
+- `World::many_entities()`
+- `World::many_entities_mut()`
+- `World::get_many_entities()`
+- `World::get_many_entities_dynamic()`
+- `World::get_many_entities_mut()`
+- `World::get_many_entities_dynamic_mut()`
+- `World::get_many_entities_from_set_mut()`
diff --git a/release-content/0.16/migration-guides/16911_Remove_unused_generic_in_DeferredWorldtrigger.md b/release-content/0.16/migration-guides/16911_Remove_unused_generic_in_DeferredWorldtrigger.md
@@ -1 +1 @@
-`DeferredWorld::trigger` no longer takes a generic argument. They type is inferred via `impl Event` instead of `T: Event`. If rust can not infer the type for you, consider specifying the type on the variable passed into the function rather than on the function itself.
+In 0.15 `DeferredWorld::trigger()` had an unused generic parameter that did not affect the type of the trigger event, so it has been removed.
diff --git a/release-content/0.16/migration-guides/17029_Refactor_hierarchyrelated_commands_to_remove_structs.md b/release-content/0.16/migration-guides/17029_Refactor_hierarchyrelated_commands_to_remove_structs.md
@@ -1,21 +1,23 @@
+Several commands have been refactored to internally use closures instead of individual structs, and their structs have been removed.
+
 If you were queuing the structs of hierarchy-related commands directly, you will need to change them to methods implemented on `EntityCommands`:
 
-| Struct                                                       | Method                                                                                         |
-|--------------------------------------------------------------|------------------------------------------------------------------------------------------------|
-| `commands.queue(AddChild { child, parent })`                 | `commands.entity(parent).add_child(child)` OR `commands.entity(child).insert(ChildOf(parent))` |
-| `commands.queue(AddChildren { children, parent })`           | `commands.entity(parent).add_children(children)`                                               |
-| `commands.queue(InsertChildren { children, parent, index })` | `commands.entity(parent).insert_children(index, children)`                                     |
-| `commands.queue(RemoveChildren { children, parent })`        | `commands.entity(parent).remove_children(children)`                                            |
-| `commands.queue(ReplaceChildren { children, parent })`       | `commands.entity(parent).replace_children(children)`                                           |
-| `commands.queue(ClearChildren { parent })`                   | `commands.entity(parent).remove::<Children>()`                                                 |
-| `commands.queue(RemoveParent { child })`                     | `commands.entity(child).remove::<ChildOf>()`                                                   |
-| `commands.queue(DespawnRecursive { entity, warn: true })`    | `commands.entity(entity).despawn()`                                                            |
-| `commands.queue(DespawnRecursive { entity, warn: false })`   | `commands.entity(entity).try_despawn()`                                                        |
-| `commands.queue(DespawnChildrenRecursive { entity, warn })`  | `commands.entity(entity).despawn_related::<Children>()`                                        |
+|Struct|Method|
+|-|-|
+|`commands.queue(AddChild { child, parent })`|`commands.entity(parent).add_child(child)` OR `commands.entity(child).insert(ChildOf(parent))`|
+|`commands.queue(AddChildren { children, parent })`|`commands.entity(parent).add_children(children)`|
+|`commands.queue(InsertChildren { children, parent, index })`|`commands.entity(parent).insert_children(index, children)`|
+|`commands.queue(RemoveChildren { children, parent })`|`commands.entity(parent).remove_children(children)`|
+|`commands.queue(ReplaceChildren { children, parent })`|`commands.entity(parent).replace_children(children)`|
+|`commands.queue(ClearChildren { parent })`|`commands.entity(parent).remove::<Children>()`|
+|`commands.queue(RemoveParent { child })`|`commands.entity(child).remove::<ChildOf>()`|
+|`commands.queue(DespawnRecursive { entity, warn: true })`|`commands.entity(entity).despawn()`|
+|`commands.queue(DespawnRecursive { entity, warn: false })`|`commands.entity(entity).try_despawn()`|
+|`commands.queue(DespawnChildrenRecursive { entity, warn })`|`commands.entity(entity).despawn_related::<Children>()`|
 
 If you were queuing the structs of event-related commands directly, you will need to change them to methods implemented on `Commands`:
 
-| Struct                                            | Method                                     |
-|---------------------------------------------------|--------------------------------------------|
-| `commands.queue(SendEvent { event })`             | `commands.send_event(event)`               |
-| `commands.queue(TriggerEvent { event, targets })` | `commands.trigger_targets(event, targets)` |
+|Struct|Method|
+|-|
+|`commands.queue(SendEvent { event })`|`commands.send_event(event)`|
+|`commands.queue(TriggerEvent { event, targets })`|`commands.trigger_targets(event, targets)`|
diff --git a/release-content/0.16/migration-guides/17032_Remove_unsound_Clone_impl_for_EntityMutExcept.md b/release-content/0.16/migration-guides/17032_Remove_unsound_Clone_impl_for_EntityMutExcept.md
@@ -1 +1 @@
-- `EntityMutExcept` can no-longer be cloned, as this violates Rust’s memory safety rules.
+`EntityMutExcept` can no-longer be cloned, as doing so violates Rust's memory safety rules.
diff --git a/release-content/0.16/migration-guides/17115_Optimize_Entitiesentity_does_not_exist_error_details_messa.md b/release-content/0.16/migration-guides/17115_Optimize_Entitiesentity_does_not_exist_error_details_messa.md
@@ -1 +1 @@
-The errors `EntityFetchError::NoSuchEntity` and `QueryEntityError::NoSuchEntity` now contain an `EntityDoesNotExistDetails` struct instead of an `UnsafeWorldCell`. If you were just printing these, they should work identically.
+`EntityFetchError` enum has been renamed to `EntityMutableFetchError`, and its `NoSuchEntity` variant has been renamed to `EntityDoesNotExist`. Furthermore, the `EntityDoesNotExist` variant now contains an `EntityDoesNotExistError` type, which provides further details on the entity that does not exist.
diff --git a/release-content/0.16/migration-guides/17380_Remove_Event_Component_trait_bound_using_a_wrapper_type_wh.md b/release-content/0.16/migration-guides/17380_Remove_Event_Component_trait_bound_using_a_wrapper_type_wh.md
@@ -1 +1,23 @@
-The `Event` trait no longer requires the `Component` trait. If you were relying on this behavior, change your trait bounds from `Event` to `Event + Component`. If you also want your `Event` type to implement `Component`, add a derive.
+In 0.15 the `Event` trait required the `Component` trait. This bound has been removed, as it was deemed confusing for users (events aren't typically attached to entities or queried in systems).
+
+If you require an event to implement `Component` (which usually isn't the case), you may manually derive it and update your trait bounds.
+
+```rust
+// 0.15
+#[derive(Event)]
+struct MyEvent;
+
+fn handle_event_component<T: Event>(event_component: T) {
+    // Access some `Component`-specific property of the event.
+    let storage_type = T::STORAGE_TYPE;
+}
+
+// 0.16
+#[derive(Event, Component)]
+struct MyEvent;
+
+fn handle_event_component<T: Event + Component>(event_component: T) {
+    // Access some `Component`-specific property of the event.
+    let storage_type = T::STORAGE_TYPE;
+}
+```
diff --git a/release-content/0.16/migration-guides/17398_Relationships_nonfragmenting_onetomany.md b/release-content/0.16/migration-guides/17398_Relationships_nonfragmenting_onetomany.md
@@ -1,9 +1,73 @@
-- Replace `ChildBuilder` with `ChildSpawnerCommands`.
-- Replace calls to `.set_parent(parent_id)` with `.insert(ChildOf(parent_id))`.
-- Replace calls to `.replace_children()` with `.remove::<Children>()` followed by `.add_children()`. Note that you’ll need to manually despawn any children that are not carried over.
-- Replace calls to `.despawn_recursive()` with `.despawn()`.
-- Replace calls to `.despawn_descendants()` with `.despawn_related::<Children>()`.
-- If you have any calls to `.despawn()` which depend on the children being preserved, you’ll need to remove the `Children` component first.
+Entity relationships are now built-in to the ECS, providing significant performance and user-experience improvements. There are several changes you may need in order to update your existing code.
+
+First, when adding children to an entity with `EntityCommands::with_children()`, the method now passes a `ChildSpawnerCommands` type to the closure instead of a `ChildBuilder`. `ChildSpawnerCommands` is slightly different from `ChildBuilder`, but is still able to accomplish the same things as before.
+
+```rust
+// 0.15
+commands.spawn_empty().with_children(|builder: &mut ChildBuilder<'_>| {
+    // Spawn a child of the parent entity;
+    builder.spawn(MyComponent(255));
+
+    // Get the `Entity` ID of the parent.
+    let parent = builder.parent_entity();
+
+    // Queue a new `Command` to be executed.
+    builder.enqueue_command(MyCommand::new(parent));
+});
+
+// 0.16
+commands.spawn_empty().with_children(|spawner: &mut ChildSpawnerCommands<'_>| {
+    spawner.spawn(MyComponent(255));
+
+    // `parent_entity()` is now `target_entity()`.
+    let parent = spawner.target_entity();
+
+    // You can now access the `Commands` struct directly, which you can then use to queue commands.
+    spawner.commands().queue(my_command(parent));
+});
+```
+
+Furthermore, the new relationship system encourages working with the relationship components (`ChildOf`, `Children`) directly. For example, setting the parent of an entity is a simple as inserting a `ChildOf` component:
+
+```rust
+// 0.15
+commands.spawn_empty().set_parent(parent);
+
+// 0.16
+commands.spawn_empty().insert(ChildOf(parent));
+```
+
+Replacing the children of a parent now requires removing the `Children` component and re-adding children individually:
+
+```rust
+// 0.15
+commands.entity(parent).replace_children(&[child1, child2]);
+
+// 0.16
+commands.entity(parent)
+    .remove::<Children>()
+    .add_children(&[child1, child2]);
+```
+
+Despawning has also been changed to remove the complexities of `despawn_recursive()` and `despawn_descendants()` from `EntityCommands`:
+
+|Action|0.15|0.16|
+|-|-|-|
+|Despawn parent and children|`despawn_recursive()`|`despawn()`|
+|Despawn children|`despawn_descendants()`|`despawn_related::<Children>()`|
+|Despawn parent|`despawn()`|`remove::<Children>()`, then `despawn()`|
+
+```rust
+// 0.15
+commands.entity(parent).despawn_recursive();
+commands.entity(parent).despawn_descendants();
+commands.entity(parent).despawn();
+
+// 0.16
+commands.entity(parent).despawn();
+commands.entity(parent).despawn_related::<Children>();
+commands.entity(parent).remove::<Children>().despawn();
+```
 
 Because relationships are now part of `bevy_ecs` itself, all methods from the previous `HierarchyQueryExt` extension trait are
 now inherent methods on `Query`.
diff --git a/release-content/0.16/migration-guides/17427_Parent__ChildOf.md b/release-content/0.16/migration-guides/17427_Parent__ChildOf.md
@@ -1 +1,15 @@
-- The `Parent` component has been renamed to `ChildOf`.
+The `Parent` component has been renamed to `ChildOf` to make it more clear that entities with a `ChildOf` component are children, not parents.
+
+Furthermore, it is now only possible to access the parent `Entity` from `ChildOf::parent()`. The `Deref` implementation has been removed and the `get()` method deprecated.
+
+```rust
+// 0.15
+let parent = *child_of
+// 0.16
+let parent = child_of.parent()
+
+// 0.15
+let parent = child_of.get()
+// 0.16
+let parent = child_of.parent()
+```
diff --git a/release-content/0.16/migration-guides/17469_Move_Resource_trait_to_its_own_file.md b/release-content/0.16/migration-guides/17469_Move_Resource_trait_to_its_own_file.md
@@ -1 +1 @@
-`bevy_ecs::system::Resource` has been moved to `bevy_ecs::resource::Resource`.
+The `Resource` trait has been moved from `bevy::ecs::system::Resource` to `bevy::ecs::resource::Resource`. Please update your imports accordingly.
diff --git a/release-content/0.16/migration-guides/17503_Refactored_ComponentHook_Parameters_into_HookContext.md b/release-content/0.16/migration-guides/17503_Refactored_ComponentHook_Parameters_into_HookContext.md
@@ -1,33 +1,41 @@
-Update the function signatures for your component hooks to only take 2 arguments, `world` and `context`. Note that because `HookContext` is plain data with all members public, you can use de-structuring to simplify migration.
+The function signature of component hooks (`ComponentHook`) has been simplified so that all arguments beyond the `DeferredWorld` is passed in a `HookContext`. Note that because `HookContext` is plain data with all public fields, you can use de-structuring to simplify migration.
 
 ```rust
-// Before
+// 0.15
 fn my_hook(
     mut world: DeferredWorld,
     entity: Entity,
     component_id: ComponentId,
-) { ... }
+) {
+    // ...
+}
 
-// After
+// 0.16
 fn my_hook(
     mut world: DeferredWorld,
     HookContext { entity, component_id, caller }: HookContext,
-) { ... }
+) {
+    // ...
+}
 ```
 
 Likewise, if you were discarding certain parameters, you can use `..` in the de-structuring:
 
 ```rust
-// Before
+// 0.15
 fn my_hook(
     mut world: DeferredWorld,
     entity: Entity,
     _: ComponentId,
-) { ... }
+) {
+    // ...
+}
 
-// After
+// 0.16
 fn my_hook(
     mut world: DeferredWorld,
     HookContext { entity, .. }: HookContext,
-) { ... }
+) {
+    // ...
+}
 ```
diff --git a/release-content/0.16/migration-guides/17679_Move_Item_and_fetch_to_QueryData_from_WorldQuery.md b/release-content/0.16/migration-guides/17679_Move_Item_and_fetch_to_QueryData_from_WorldQuery.md
@@ -1 +1 @@
-The `WorldQuery::Item` type and `WorldQuery::fetch` method have been moved to `QueryData`, as they were not useful for `QueryFilter` types.
+The `WorldQuery::Item` associated type and `WorldQuery::fetch()` method have been moved to `QueryData`, as they were not useful for `QueryFilter`-based types.
diff --git a/release-content/0.16/migration-guides/18080_Remove_ChildOfget_and_Deref_impl.md b/release-content/0.16/migration-guides/18080_Remove_ChildOfget_and_Deref_impl.md
diff --git a/release-content/0.16/migration-guides/18082_Make_Querysingle_and_friends_return_a_Result.md b/release-content/0.16/migration-guides/18082_Make_Querysingle_and_friends_return_a_Result.md
@@ -1,19 +1,17 @@
-`Query::single`, `Query::single_mut` and their `QueryState` equivalents now return a `Result`. Generally, you’ll want to:
+`Query::single()`, `Query::single_mut()` and their `QueryState` equivalents now return a `Result`. Generally, you'll want to:
 
-- Use Bevy 0.16’s system error handling to return a `Result` using the `?` operator.
-- Use a `let else Ok(data)` block to early return if it’s an expected failure.
+- Use Bevy 0.16's system error handling to return a `Result` using the `?` operator.
+- Use a `let Ok(data) = result else {}` block to early return if there's an expected failure.
 - Use `unwrap()` or `Ok` destructuring inside of tests.
 
-The old `Query::get_single` (etc) methods which did this have been deprecated.
+The old `Query::get_single()` and related methods have been deprecated.
 
-If you are using `anyhow`, you will experience namespace clashes between Bevy's catch-all `Result` and `anyhow`'s type of the same name.
-Within Bevy-specific projects, you should migrate to use the `bevy::ecs::error::Result` due to its better backtraces, and file requests for any missing functionality.
-For projects that support both Bevy and non-Bevy users, you should define a feature-gated type alias and avoid glob-importing `bevy::prelude`:
+If you are using `anyhow`, you will experience namespace clashes between Bevy's catch-all `Result` and `anyhow::Result`. Within Bevy-specific projects, you should migrate to use the new `bevy::ecs::error::Result` due to its improved backtraces. (If you discover missing functionality, please feel free to open a pull request adding it!) For projects that support both Bevy and non-Bevy users, you should define a feature-gated type alias and avoid glob-importing `bevy::prelude`:
 
 ```rust
-#[cfg(feature="bevy")]
+#[cfg(feature = "bevy")]
 type Result = bevy::ecs::error::Result;
 
-#[cfg(not(feature="bevy"))]
+#[cfg(not(feature = "bevy"))]
 type Result = anyhow::Result;
 ```
diff --git a/release-content/0.16/migration-guides/18157_Remove_lifetime_from_QueryEntityError.md b/release-content/0.16/migration-guides/18157_Remove_lifetime_from_QueryEntityError.md
diff --git a/release-content/0.16/migration-guides/18173_Queued_component_registration.md b/release-content/0.16/migration-guides/18173_Queued_component_registration.md
diff --git a/release-content/0.16/migration-guides/18454_Make_system_param_validation_rely_on_the_unified_ECS_error.md b/release-content/0.16/migration-guides/18454_Make_system_param_validation_rely_on_the_unified_ECS_error.md
diff --git a/release-content/0.16/migration-guides/_guides.toml b/release-content/0.16/migration-guides/_guides.toml

Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		-- exchange `Entities::flush_and_reserve_invalid_assuming_no_entities` for `reserve` and `flush_as_invalid` and notify us if that’s insufficient
	`1`	+`Entities::flush_and_reserve_invalid_assuming_no_entities()` was a specialized method primarily used in 0.14 and earlier's rendering world design. With 0.15, `flush_and_reserve_invalid_assuming_no_entities()` went unused, so it now has been removed. If you previously required this method, you should switch to calling `Entities::reserve_entities()` and `Entities::flush_as_invalid()`.
Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		-`DeferredWorld::trigger` no longer takes a generic argument. They type is inferred via `impl Event` instead of `T: Event`. If rust can not infer the type for you, consider specifying the type on the variable passed into the function rather than on the function itself.
	`1`	+In 0.15 `DeferredWorld::trigger()` had an unused generic parameter that did not affect the type of the trigger event, so it has been removed.
Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		-- `EntityMutExcept` can no-longer be cloned, as this violates Rust’s memory safety rules.
	`1`	+`EntityMutExcept` can no-longer be cloned, as doing so violates Rust's memory safety rules.
Original file line number	Diff line number	Diff line change
`@@ -1 +1 @@`
`1`		-The errors `EntityFetchError::NoSuchEntity` and `QueryEntityError::NoSuchEntity` now contain an `EntityDoesNotExistDetails` struct instead of an `UnsafeWorldCell`. If you were just printing these, they should work identically.
	`1`	+`EntityFetchError` enum has been renamed to `EntityMutableFetchError`, and its `NoSuchEntity` variant has been renamed to `EntityDoesNotExist`. Furthermore, the `EntityDoesNotExist` variant now contains an `EntityDoesNotExistError` type, which provides further details on the entity that does not exist.