diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..9bd99d1
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,21 @@
+all notable changes to this project will be documented in this file
+
+the format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and [Common Changelog](https://common-changelog.org/), and this project vaguely adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html)
+
+## unreleased
+
+### changed
+
+- reactive collections `MutableVec` and `MutableBTreeMap` are now lock-free and managed by entities and components
+- `Signal*Clone` renamed to `Signal*DynClone`
+
+### added
+
+- `SignalProcessing` `SystemSet` for scheduling systems around signal processing
+- `MutableVec` and `MutableBTreeMap` can be built from with `FromWorld`, `&mut World`, and `&mut Commands`
+- `MutableVecBuilder` and `MutableBTreeMapBuilder`
+- `JonmoBuilder::on_spawn_with_system` convenience method
+- `JonmoBuilder::observe` convenience method
+- `JonmoBuilder::on_signal_with_entity` convenience method
+- deref convenience for `LazyEntity`
+
diff --git a/Cargo.lock b/Cargo.lock
index ad505ad..ba19426 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -15,7 +15,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d0bf66a7bf0b7ea4fd7742d50b64782a88f99217cf246b3f93b4162528dde520"
 dependencies = [
  "accesskit",
- "hashbrown",
+ "hashbrown 0.15.5",
  "immutable-chunkmap",
 ]
 
@@ -27,7 +27,7 @@ checksum = "09e230718177753b4e4ad9e1d9f6cfc2f4921212d4c1c480b253f526babb258d"
 dependencies = [
  "accesskit",
  "accesskit_consumer",
- "hashbrown",
+ "hashbrown 0.15.5",
  "objc2",
  "objc2-app-kit",
  "objc2-foundation",
@@ -41,7 +41,7 @@ checksum = "65178f3df98a51e4238e584fcb255cb1a4f9111820848eeddd37663be40a625f"
 dependencies = [
  "accesskit",
  "accesskit_consumer",
- "hashbrown",
+ "hashbrown 0.15.5",
  "paste",
  "static_assertions",
  "windows 0.58.0",
@@ -83,7 +83,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ed7572b7ba83a31e20d1b48970ee402d2e3e0537dcfe0a3ff4d6eb7508617d43"
 dependencies = [
  "alsa-sys",
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "cfg-if",
  "libc",
 ]
@@ -105,7 +105,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ef6978589202a00cd7e118380c448a08b6ed394c3a8df3a430d0898e3a42d046"
 dependencies = [
  "android-properties",
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "cc",
  "cesu8",
  "jni",
@@ -207,9 +207,9 @@ dependencies = [
 
 [[package]]
 name = "async-channel"
-version = "2.3.1"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89b47800b0be77592da0afd425cc03468052844aff33b84e33cc696f64e77b6a"
+checksum = "924ed96dd52d1b75e9c1a3e6275715fd320f5f9439fb5a4a11fa51f4221158d2"
 dependencies = [
  "concurrent-queue",
  "event-listener-strategy",
@@ -219,9 +219,9 @@ dependencies = [
 
 [[package]]
 name = "async-executor"
-version = "1.13.2"
+version = "1.13.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb812ffb58524bdd10860d7d974e2f01cc0950c2438a74ee5ec2e2280c6c4ffa"
+checksum = "497c00e0fd83a72a79a39fcbd8e3e2f055d6f6c7e025f3b3d91f4f8e76527fb8"
 dependencies = [
  "async-task",
  "concurrent-queue",
@@ -233,9 +233,9 @@ dependencies = [
 
 [[package]]
 name = "async-fs"
-version = "2.1.2"
+version = "2.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebcd09b382f40fcd159c2d695175b2ae620ffa5f3bd6f664131efff4e8b9e04a"
+checksum = "8034a681df4aed8b8edbd7fbe472401ecf009251c8b40556b304567052e294c5"
 dependencies = [
  "async-lock",
  "blocking",
@@ -244,9 +244,9 @@ dependencies = [
 
 [[package]]
 name = "async-lock"
-version = "3.4.0"
+version = "3.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff6e472cdea888a4bd64f342f09b3f50e1886d32afe8df3d663c01140b811b18"
+checksum = "5fd03604047cee9b6ce9de9f70c6cd540a0520c813cbd49bae61f33ab80ed1dc"
 dependencies = [
  "event-listener",
  "event-listener-strategy",
@@ -283,9 +283,9 @@ dependencies = [
 
 [[package]]
 name = "autocfg"
-version = "1.4.0"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
 
 [[package]]
 name = "base64"
@@ -349,7 +349,7 @@ dependencies = [
  "ron",
  "serde",
  "smallvec",
- "thiserror 2.0.12",
+ "thiserror 2.0.17",
  "thread_local",
  "tracing",
  "uuid",
@@ -372,7 +372,7 @@ dependencies = [
  "ctrlc",
  "downcast-rs",
  "log",
- "thiserror 2.0.12",
+ "thiserror 2.0.17",
  "variadics_please",
  "wasm-bindgen",
  "web-sys",
@@ -396,7 +396,7 @@ dependencies = [
  "bevy_tasks",
  "bevy_utils",
  "bevy_window",
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "blake3",
  "crossbeam-channel",
  "derive_more",
@@ -410,7 +410,7 @@ dependencies = [
  "ron",
  "serde",
  "stackfuture",
- "thiserror 2.0.12",
+ "thiserror 2.0.17",
  "tracing",
  "uuid",
  "wasm-bindgen",
@@ -460,7 +460,7 @@ dependencies = [
  "derive_more",
  "encase",
  "serde",
- "thiserror 2.0.12",
+ "thiserror 2.0.17",
  "wgpu-types",
 ]
 
@@ -484,13 +484,13 @@ dependencies = [
  "bevy_transform",
  "bevy_utils",
  "bevy_window",
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "bytemuck",
  "nonmax",
  "radsort",
  "serde",
  "smallvec",
- "thiserror 2.0.12",
+ "thiserror 2.0.17",
  "tracing",
 ]
 
@@ -536,7 +536,7 @@ dependencies = [
  "bevy_reflect",
  "bevy_tasks",
  "bevy_utils",
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "bumpalo",
  "concurrent-queue",
  "derive_more",
@@ -547,7 +547,7 @@ dependencies = [
  "nonmax",
  "serde",
  "smallvec",
- "thiserror 2.0.12",
+ "thiserror 2.0.17",
  "variadics_please",
 ]
 
@@ -586,7 +586,7 @@ dependencies = [
  "bevy_time",
  "bevy_utils",
  "gilrs",
- "thiserror 2.0.12",
+ "thiserror 2.0.17",
  "tracing",
 ]
 
@@ -658,7 +658,7 @@ dependencies = [
  "serde",
  "serde_json",
  "smallvec",
- "thiserror 2.0.12",
+ "thiserror 2.0.17",
  "tracing",
 ]
 
@@ -675,7 +675,7 @@ dependencies = [
  "bevy_platform",
  "bevy_reflect",
  "bevy_utils",
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "bytemuck",
  "futures-lite",
  "guillotiere",
@@ -685,7 +685,7 @@ dependencies = [
  "rectangle-pack",
  "ruzstd",
  "serde",
- "thiserror 2.0.12",
+ "thiserror 2.0.17",
  "tracing",
  "wgpu-types",
 ]
@@ -705,7 +705,7 @@ dependencies = [
  "derive_more",
  "log",
  "smol_str",
- "thiserror 2.0.12",
+ "thiserror 2.0.17",
 ]
 
 [[package]]
@@ -721,7 +721,7 @@ dependencies = [
  "bevy_reflect",
  "bevy_window",
  "log",
- "thiserror 2.0.12",
+ "thiserror 2.0.17",
 ]
 
 [[package]]
@@ -794,7 +794,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "syn",
- "toml_edit",
+ "toml_edit 0.22.27",
 ]
 
 [[package]]
@@ -813,7 +813,7 @@ dependencies = [
  "rand_distr",
  "serde",
  "smallvec",
- "thiserror 2.0.12",
+ "thiserror 2.0.17",
  "variadics_please",
 ]
 
@@ -833,11 +833,11 @@ dependencies = [
  "bevy_reflect",
  "bevy_transform",
  "bevy_utils",
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "bytemuck",
  "hexasphere",
  "serde",
- "thiserror 2.0.12",
+ "thiserror 2.0.17",
  "tracing",
  "wgpu-types",
 ]
@@ -872,7 +872,7 @@ dependencies = [
  "bevy_transform",
  "bevy_utils",
  "bevy_window",
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "bytemuck",
  "derive_more",
  "fixedbitset",
@@ -881,7 +881,7 @@ dependencies = [
  "radsort",
  "smallvec",
  "static_assertions",
- "thiserror 2.0.12",
+ "thiserror 2.0.17",
  "tracing",
 ]
 
@@ -920,7 +920,7 @@ dependencies = [
  "critical-section",
  "foldhash",
  "getrandom 0.2.16",
- "hashbrown",
+ "hashbrown 0.15.5",
  "portable-atomic",
  "portable-atomic-util",
  "serde",
@@ -955,7 +955,7 @@ dependencies = [
  "serde",
  "smallvec",
  "smol_str",
- "thiserror 2.0.12",
+ "thiserror 2.0.17",
  "uuid",
  "variadics_please",
  "wgpu-types",
@@ -999,7 +999,7 @@ dependencies = [
  "bevy_transform",
  "bevy_utils",
  "bevy_window",
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "bytemuck",
  "codespan-reporting",
  "derive_more",
@@ -1018,7 +1018,7 @@ dependencies = [
  "send_wrapper",
  "serde",
  "smallvec",
- "thiserror 2.0.12",
+ "thiserror 2.0.17",
  "tracing",
  "variadics_please",
  "wasm-bindgen",
@@ -1055,7 +1055,7 @@ dependencies = [
  "bevy_utils",
  "derive_more",
  "serde",
- "thiserror 2.0.12",
+ "thiserror 2.0.17",
  "uuid",
 ]
 
@@ -1080,7 +1080,7 @@ dependencies = [
  "bevy_transform",
  "bevy_utils",
  "bevy_window",
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "bytemuck",
  "derive_more",
  "fixedbitset",
@@ -1164,7 +1164,7 @@ dependencies = [
  "serde",
  "smallvec",
  "sys-locale",
- "thiserror 2.0.12",
+ "thiserror 2.0.17",
  "tracing",
  "unicode-bidi",
 ]
@@ -1199,7 +1199,7 @@ dependencies = [
  "bevy_utils",
  "derive_more",
  "serde",
- "thiserror 2.0.12",
+ "thiserror 2.0.17",
 ]
 
 [[package]]
@@ -1233,7 +1233,7 @@ dependencies = [
  "nonmax",
  "smallvec",
  "taffy",
- "thiserror 2.0.12",
+ "thiserror 2.0.17",
  "tracing",
 ]
 
@@ -1308,7 +1308,7 @@ version = "0.70.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f49d8fed880d473ea71efb9bf597651e77201bdd4893efe54c9e5d65ae04ce6f"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "cexpr",
  "clang-sys",
  "itertools 0.13.0",
@@ -1324,11 +1324,11 @@ dependencies = [
 
 [[package]]
 name = "bindgen"
-version = "0.72.0"
+version = "0.72.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f72209734318d0b619a5e0f5129918b848c416e122a3c4ce054e03cb87b726f"
+checksum = "993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "cexpr",
  "clang-sys",
  "itertools 0.13.0",
@@ -1378,11 +1378,11 @@ checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
 [[package]]
 name = "bitflags"
-version = "2.9.1"
+version = "2.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b8e56985ec62d17e9c1001dc89c88ecd7dc08e47eba5ec7c29c7b5eeecde967"
+checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
 dependencies = [
- "serde",
+ "serde_core",
 ]
 
 [[package]]
@@ -1415,9 +1415,9 @@ dependencies = [
 
 [[package]]
 name = "blocking"
-version = "1.6.1"
+version = "1.6.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "703f41c54fc768e63e091340b424302bb1c29ef4aa0c7f10fe849dfb114d29ea"
+checksum = "e83f8d02be6967315521be875afa792a316e28d57b5a2d401897e2a7921b7f21"
 dependencies = [
  "async-channel",
  "async-task",
@@ -1428,24 +1428,24 @@ dependencies = [
 
 [[package]]
 name = "bumpalo"
-version = "3.18.1"
+version = "3.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "793db76d6187cd04dff33004d8e6c9cc4e05cd330500379d2394209271b4aeee"
+checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
 
 [[package]]
 name = "bytemuck"
-version = "1.23.1"
+version = "1.24.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c76a5792e44e4abe34d3abf15636779261d45a7450612059293d1d2cfc63422"
+checksum = "1fbdf580320f38b612e485521afda1ee26d10cc9884efaaa750d383e13e3c5f4"
 dependencies = [
  "bytemuck_derive",
 ]
 
 [[package]]
 name = "bytemuck_derive"
-version = "1.9.3"
+version = "1.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ecc273b49b3205b83d648f0690daa588925572cc5063745bfe547fe7ec8e1a1"
+checksum = "f9abbd1bc6865053c427f7198e6af43bfdedc55ab791faed4fbd361d789575ff"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -1476,7 +1476,7 @@ version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b99da2f8558ca23c71f4fd15dc57c906239752dd27ff3c00a1d56b685b7cbfec"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "log",
  "polling",
  "rustix 0.38.44",
@@ -1486,10 +1486,11 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.2.26"
+version = "1.2.43"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "956a5e21988b87f372569b66183b78babf23ebc2e744b733e4350a752c4dafac"
+checksum = "739eb0f94557554b3ca9a86d2d37bebd49c5e6d0c1d2bda35ba5bdac830befc2"
 dependencies = [
+ "find-msvc-tools",
  "jobserver",
  "libc",
  "shlex",
@@ -1512,9 +1513,9 @@ dependencies = [
 
 [[package]]
 name = "cfg-if"
-version = "1.0.1"
+version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9555578bc9e57714c812a1f84e4fc5b4d21fcb063490c624de019f7464c91268"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "cfg_aliases"
@@ -1581,9 +1582,12 @@ checksum = "32b13ea120a812beba79e34316b3942a857c86ec1593cb34f27bb28272ce2cca"
 
 [[package]]
 name = "const_panic"
-version = "0.2.12"
+version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2459fc9262a1aa204eb4b5764ad4f189caec88aea9634389c0a25f8be7f6265e"
+checksum = "e262cdaac42494e3ae34c43969f9cdeb7da178bdb4b66fa6a1ea2edb4c8ae652"
+dependencies = [
+ "typewit",
+]
 
 [[package]]
 name = "const_soft_float"
@@ -1673,7 +1677,7 @@ version = "0.2.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ceec7a6067e62d6f931a2baf6f3a751f4a892595bcec1461a3c94ef9949864b6"
 dependencies = [
- "bindgen 0.72.0",
+ "bindgen 0.72.1",
 ]
 
 [[package]]
@@ -1682,7 +1686,7 @@ version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e418dd4f5128c3e93eab12246391c54a20c496811131f85754dc8152ee207892"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "fontdb",
  "log",
  "rangemap",
@@ -1724,9 +1728,9 @@ dependencies = [
 
 [[package]]
 name = "crc32fast"
-version = "1.4.2"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a97769d94ddab943e4510d138150169a2758b5ef3eb191a9ee688de3e23ef7b3"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
 dependencies = [
  "cfg-if",
 ]
@@ -1763,18 +1767,19 @@ checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
 [[package]]
 name = "crunchy"
-version = "0.2.3"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43da5946c66ffcc7745f48db692ffbb10a83bfe0afd96235c5c2a4fb23994929"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
 
 [[package]]
 name = "ctrlc"
-version = "3.4.7"
+version = "3.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46f93780a459b7d656ef7f071fe699c4d3d2cb201c4b24d085b6ddc505276e73"
+checksum = "881c5d0a13b2f1498e2306e82cbada78390e152d4b1378fb28a84f4dcd0dc4f3"
 dependencies = [
- "nix 0.30.1",
- "windows-sys 0.59.0",
+ "dispatch",
+ "nix",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -1839,18 +1844,18 @@ dependencies = [
 
 [[package]]
 name = "document-features"
-version = "0.2.11"
+version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95249b50c6c185bee49034bcb378a49dc2b5dff0be90ff6616d31d64febab05d"
+checksum = "d4b8a88685455ed29a21542a33abd9cb6510b6b129abadabdcef0f4c55bc8f61"
 dependencies = [
  "litrs",
 ]
 
 [[package]]
 name = "downcast-rs"
-version = "2.0.1"
+version = "2.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ea8a8b81cacc08888170eef4d13b775126db426d0b348bee9d18c2c1eaf123cf"
+checksum = "117240f60069e65410b3ae1bb213295bd828f707b5bec6596a1afc8793ce0cbc"
 
 [[package]]
 name = "dpi"
@@ -1860,9 +1865,9 @@ checksum = "d8b14ccef22fc6f5a8f4d7d768562a182c04ce9a3b3157b91390b52ddfdf1a76"
 
 [[package]]
 name = "dyn-clone"
-version = "1.0.19"
+version = "1.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c7a8fb8a9fbf66c1f703fe16184d10ca0ee9d23be5b4436400408ba54a95005"
+checksum = "d0881ea181b1df73ff77ffaaf9c7544ecc11e82fba9b5f27b262a3c73a332555"
 
 [[package]]
 name = "either"
@@ -1916,22 +1921,23 @@ checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
 
 [[package]]
 name = "erased-serde"
-version = "0.4.6"
+version = "0.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e004d887f51fcb9fef17317a2f3525c887d8aa3f4f50fed920816a688284a5b7"
+checksum = "259d404d09818dec19332e31d94558aeb442fea04c817006456c24b5460bbd4b"
 dependencies = [
  "serde",
+ "serde_core",
  "typeid",
 ]
 
 [[package]]
 name = "errno"
-version = "0.3.12"
+version = "0.3.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cea14ef9355e3beab063703aa9dab15afd25f0667c341310c1e5274bb1d0da18"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -1945,9 +1951,9 @@ dependencies = [
 
 [[package]]
 name = "event-listener"
-version = "5.4.0"
+version = "5.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3492acde4c3fc54c845eaab3eed8bd00c7a7d881f78bfc801e43a93dec1331ae"
+checksum = "e13b66accf52311f30a0db42147dadea9850cb48cd070028831ae5f5d4b856ab"
 dependencies = [
  "concurrent-queue",
  "parking",
@@ -1979,6 +1985,12 @@ dependencies = [
  "simd-adler32",
 ]
 
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "52051878f80a721bb68ebfbc930e07b65ba72f2da88968ea5c06fd6ca3d3a127"
+
 [[package]]
 name = "fixedbitset"
 version = "0.5.7"
@@ -1987,9 +1999,9 @@ checksum = "1d674e81391d1e1ab681a28d99df07927c6d4aa5b027d7da16ba32d1d21ecd99"
 
 [[package]]
 name = "flate2"
-version = "1.1.2"
+version = "1.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4a3d7db9596fecd151c5f638c0ee5d5bd487b6e0ea232e5dc96d5250f6f94b1d"
+checksum = "bfe33edd8e85a12a67454e37f8c75e730830d83e313556ab9ebf9ee7fbeb3bfb"
 dependencies = [
  "crc32fast",
  "miniz_oxide",
@@ -2009,9 +2021,9 @@ checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
 
 [[package]]
 name = "font-types"
-version = "0.9.0"
+version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02a596f5713680923a2080d86de50fe472fb290693cf0f701187a1c8b36996b7"
+checksum = "511e2c18a516c666d27867d2f9821f76e7d591f762e9fc41dd6cc5c90fe54b0b"
 dependencies = [
  "bytemuck",
 ]
@@ -2089,9 +2101,9 @@ checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
 
 [[package]]
 name = "futures-lite"
-version = "2.6.0"
+version = "2.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f5edaec856126859abb19ed65f39e90fea3a9574b9707f13539acf4abf7eb532"
+checksum = "f78e10609fe0e0b3f4157ffab1876319b5b0db102a2c60dc4626306dc46b44ad"
 dependencies = [
  "fastrand",
  "futures-core",
@@ -2102,12 +2114,12 @@ dependencies = [
 
 [[package]]
 name = "gethostname"
-version = "0.4.3"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0176e0459c2e4a1fe232f984bca6890e681076abb9934f6cea7c326f3fc47818"
+checksum = "1bd49230192a3797a9a4d6abe9b3eed6f7fa4c8a8a4947977c6f80025f92cbd8"
 dependencies = [
- "libc",
- "windows-targets 0.48.5",
+ "rustix 1.1.2",
+ "windows-link",
 ]
 
 [[package]]
@@ -2119,21 +2131,21 @@ dependencies = [
  "cfg-if",
  "js-sys",
  "libc",
- "wasi 0.11.1+wasi-snapshot-preview1",
+ "wasi",
  "wasm-bindgen",
 ]
 
 [[package]]
 name = "getrandom"
-version = "0.3.3"
+version = "0.3.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26145e563e54f2cadc477553f1ec5ee650b00862f0a58bcd12cbdc5f0ea2d2f4"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
 dependencies = [
  "cfg-if",
  "js-sys",
  "libc",
  "r-efi",
- "wasi 0.14.2+wasi-0.2.4",
+ "wasip2",
  "wasm-bindgen",
 ]
 
@@ -2152,9 +2164,9 @@ dependencies = [
 
 [[package]]
 name = "gilrs-core"
-version = "0.6.4"
+version = "0.6.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a6d95ae10ce5aa99543a28cf74e41c11f3b9e3c14f0452bbde46024753cd683e"
+checksum = "be11a71ac3564f6965839e2ed275bf4fcf5ce16d80d396e1dfdb7b2d80bd587e"
 dependencies = [
  "core-foundation 0.10.1",
  "inotify",
@@ -2163,12 +2175,12 @@ dependencies = [
  "libc",
  "libudev-sys",
  "log",
- "nix 0.29.0",
+ "nix",
  "uuid",
  "vec_map",
  "wasm-bindgen",
  "web-sys",
- "windows 0.61.2",
+ "windows 0.62.2",
 ]
 
 [[package]]
@@ -2196,9 +2208,9 @@ dependencies = [
 
 [[package]]
 name = "glob"
-version = "0.3.2"
+version = "0.3.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8d1add55171497b4705a648c6b583acafb01d58050a51727785f0b2c8e0a2b2"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
 
 [[package]]
 name = "glow"
@@ -2263,7 +2275,7 @@ version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fbcd2dba93594b227a1f57ee09b8b9da8892c34d55aa332e034a228d0fe6a171"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "gpu-alloc-types",
 ]
 
@@ -2273,7 +2285,7 @@ version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "98ff03b468aa837d70984d55f5d3f846f6ec31fe34bbb97c4f85219caeee1ca4"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
 ]
 
 [[package]]
@@ -2294,9 +2306,9 @@ version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b89c83349105e3732062a895becfc71a8f921bb71ecbbdd8ff99263e3b53a0ca"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "gpu-descriptor-types",
- "hashbrown",
+ "hashbrown 0.15.5",
 ]
 
 [[package]]
@@ -2305,7 +2317,7 @@ version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fdf242682df893b86f33a73828fb09ca4b2d3bb6cc95249707fc684d27484b91"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
 ]
 
 [[package]]
@@ -2326,12 +2338,13 @@ dependencies = [
 
 [[package]]
 name = "half"
-version = "2.6.0"
+version = "2.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "459196ed295495a68f7d7fe1d84f6c4b7ff0e21fe3017b2f283c6fac3ad803c9"
+checksum = "6ea2d84b969582b4b1864a92dc5d27cd2b77b622a8d79306834f1be5ba20d84b"
 dependencies = [
  "cfg-if",
  "crunchy",
+ "zerocopy",
 ]
 
 [[package]]
@@ -2345,15 +2358,21 @@ dependencies = [
 
 [[package]]
 name = "hashbrown"
-version = "0.15.4"
+version = "0.15.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5971ac85611da7067dbfcabef3c70ebb5606018acd9e2a3903a0da507521e0d5"
+checksum = "9229cfe53dfd69f0609a49f65461bd93001ea1ef889cd5529dd176593f5338a1"
 dependencies = [
  "equivalent",
  "foldhash",
  "serde",
 ]
 
+[[package]]
+name = "hashbrown"
+version = "0.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5419bdc4f6a9207fbeba6d11b604d481addf78ecd10c11ad51e76c2f6482748d"
+
 [[package]]
 name = "heapless"
 version = "0.8.0"
@@ -2396,34 +2415,36 @@ checksum = "dfa686283ad6dd069f105e5ab091b04c62850d3e4cf5d67debad1933f55023df"
 
 [[package]]
 name = "image"
-version = "0.25.6"
+version = "0.25.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db35664ce6b9810857a38a906215e75a9c879f0696556a39f59c62829710251a"
+checksum = "529feb3e6769d234375c4cf1ee2ce713682b8e76538cb13f9fc23e1400a591e7"
 dependencies = [
  "bytemuck",
  "byteorder-lite",
+ "moxcms",
  "num-traits",
  "png",
 ]
 
 [[package]]
 name = "immutable-chunkmap"
-version = "2.0.6"
+version = "2.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12f97096f508d54f8f8ab8957862eee2ccd628847b6217af1a335e1c44dee578"
+checksum = "9a3e98b1520e49e252237edc238a39869da9f3241f2ec19dc788c1d24694d1e4"
 dependencies = [
  "arrayvec",
 ]
 
 [[package]]
 name = "indexmap"
-version = "2.9.0"
+version = "2.12.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cea70ddb795996207ad57735b50c5982d8844f38ba9ee5f1aedcfb708a2aa11e"
+checksum = "6717a8d2a5a929a1a2eb43a12812498ed141a0bcfb7e8f7844fbdbe4303bba9f"
 dependencies = [
  "equivalent",
- "hashbrown",
+ "hashbrown 0.16.0",
  "serde",
+ "serde_core",
 ]
 
 [[package]]
@@ -2438,7 +2459,7 @@ version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f37dccff2791ab604f9babef0ba14fbe0be30bd368dc541e2b08d07c8aa908f3"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "inotify-sys",
  "libc",
 ]
@@ -2510,11 +2531,11 @@ checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130"
 
 [[package]]
 name = "jobserver"
-version = "0.1.33"
+version = "0.1.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38f262f097c174adebe41eb73d66ae9c06b2844fb0da69969647bbddd9b0538a"
+checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33"
 dependencies = [
- "getrandom 0.3.3",
+ "getrandom 0.3.4",
  "libc",
 ]
 
@@ -2534,15 +2555,16 @@ dependencies = [
  "document-features",
  "dyn-clone",
  "enclose",
- "getrandom 0.3.3",
- "rand 0.9.1",
+ "getrandom 0.3.4",
+ "rand 0.9.2",
+ "test-log",
 ]
 
 [[package]]
 name = "js-sys"
-version = "0.3.77"
+version = "0.3.81"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cfaf33c695fc6e08064efbc1f72ec937429614f25eef83af942d0e227c3a28f"
+checksum = "ec48937a97411dcb524a265206ccd4c90bb711fca92b2792c407f268825b9305"
 dependencies = [
  "once_cell",
  "wasm-bindgen",
@@ -2593,18 +2615,18 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.172"
+version = "0.2.177"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
+checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976"
 
 [[package]]
 name = "libloading"
-version = "0.8.8"
+version = "0.8.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07033963ba89ebaf1584d767badaa2e8fcec21aedea6b8c0346d487d49c28667"
+checksum = "d7c4b02199fee7c5d21a5ae7d8cfa79a6ef5bb2fc834d6e9058e89c825efdc55"
 dependencies = [
  "cfg-if",
- "windows-targets 0.53.1",
+ "windows-link",
 ]
 
 [[package]]
@@ -2615,13 +2637,13 @@ checksum = "f9fbbcab51052fe104eb5e5d351cf728d30a5be1fe14d9be8a3b097481fb97de"
 
 [[package]]
 name = "libredox"
-version = "0.1.3"
+version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0ff37bd590ca25063e35af745c343cb7a0271906fb7b37e4813e8f79f00268d"
+checksum = "416f7e718bdb06000964960ffa43b4335ad4012ae8b99060261aa4a8088d5ccb"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "libc",
- "redox_syscall 0.5.12",
+ "redox_syscall 0.5.18",
 ]
 
 [[package]]
@@ -2642,37 +2664,36 @@ checksum = "d26c52dbd32dccf2d10cac7725f8eae5296885fb5703b261f7d0a0739ec807ab"
 
 [[package]]
 name = "linux-raw-sys"
-version = "0.9.4"
+version = "0.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd945864f07fe9f5371a27ad7b52a172b4b499999f1d97574c9fa68373937e12"
+checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
 
 [[package]]
 name = "litrs"
-version = "0.4.1"
+version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4ce301924b7887e9d637144fdade93f9dfff9b60981d4ac161db09720d39aa5"
+checksum = "11d3d7f243d5c5a8b9bb5d6dd2b1602c0cb0b9db1621bafc7ed66e35ff9fe092"
 
 [[package]]
 name = "lock_api"
-version = "0.4.13"
+version = "0.4.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96936507f153605bddfcda068dd804796c84324ed2510809e5b2a624c81da765"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
 dependencies = [
- "autocfg",
  "scopeguard",
 ]
 
 [[package]]
 name = "log"
-version = "0.4.27"
+version = "0.4.28"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "13dc2df351e3202783a1fe0d44375f7295ffb4049267b0f3018346dc122a1d94"
+checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
 
 [[package]]
 name = "mach2"
-version = "0.4.2"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19b955cdeb2a02b9117f121ce63aa52d08ade45de53e48fe6a38b39c10f6f709"
+checksum = "d640282b302c0bb0a2a8e0233ead9035e3bed871f0b7e81fe4a1ec829765db44"
 dependencies = [
  "libc",
 ]
@@ -2688,24 +2709,24 @@ dependencies = [
 
 [[package]]
 name = "matchers"
-version = "0.1.0"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558"
+checksum = "d1525a2a28c7f4fa0fc98bb91ae755d1e2d1505079e05539e35bc876b5d65ae9"
 dependencies = [
- "regex-automata 0.1.10",
+ "regex-automata",
 ]
 
 [[package]]
 name = "memchr"
-version = "2.7.5"
+version = "2.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32a282da65faaf38286cf3be983213fcf1d2e2a58700e808f83f4ea9a4804bc0"
+checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
 
 [[package]]
 name = "memmap2"
-version = "0.9.5"
+version = "0.9.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd3f7eed9d3848f8b98834af67102b720745c4ec028fcd0aa0239277e7de374f"
+checksum = "744133e4a0e0a658e1374cf3bf8e415c4052a15a111acd372764c55b4177d490"
 dependencies = [
  "libc",
 ]
@@ -2716,7 +2737,7 @@ version = "0.31.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f569fb946490b5743ad69813cb19629130ce9374034abe31614a36402d18f99e"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "block",
  "core-graphics-types",
  "foreign-types",
@@ -2741,6 +2762,16 @@ dependencies = [
  "simd-adler32",
 ]
 
+[[package]]
+name = "moxcms"
+version = "0.7.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "692af879e4d9383c0fd9dec15524af6b6977c8bf1c6b278a4526d5341347c574"
+dependencies = [
+ "num-traits",
+ "pxfm",
+]
+
 [[package]]
 name = "naga"
 version = "24.0.0"
@@ -2749,7 +2780,7 @@ checksum = "e380993072e52eef724eddfcde0ed013b0c023c3f0417336ed041aa9f076994e"
 dependencies = [
  "arrayvec",
  "bit-set 0.8.0",
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "cfg_aliases",
  "codespan-reporting",
  "hexf-parse",
@@ -2760,7 +2791,7 @@ dependencies = [
  "spirv",
  "strum",
  "termcolor",
- "thiserror 2.0.12",
+ "thiserror 2.0.17",
  "unicode-xid",
 ]
 
@@ -2777,7 +2808,7 @@ dependencies = [
  "naga",
  "once_cell",
  "regex",
- "regex-syntax 0.8.5",
+ "regex-syntax",
  "rustc-hash 1.1.0",
  "thiserror 1.0.69",
  "tracing",
@@ -2790,7 +2821,7 @@ version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2076a31b7010b17a38c01907c45b945e8f11495ee4dd588309718901b1f7a5b7"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "jni-sys",
  "log",
  "ndk-sys 0.5.0+25.2.9519653",
@@ -2804,7 +2835,7 @@ version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c3f42e7bbe13d351b6bead8286a43aac9534b82bd3cc43e47037f012ebfd62d4"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "jni-sys",
  "log",
  "ndk-sys 0.6.0+11769913",
@@ -2837,25 +2868,13 @@ dependencies = [
  "jni-sys",
 ]
 
-[[package]]
-name = "nix"
-version = "0.29.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "71e2746dc3a24dd78b3cfcb7be93368c6de9963d30f43a6a73998a9cf4b17b46"
-dependencies = [
- "bitflags 2.9.1",
- "cfg-if",
- "cfg_aliases",
- "libc",
-]
-
 [[package]]
 name = "nix"
 version = "0.30.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "74523f3a35e05aba87a1d978330aef40f67b0304ac79c1c00b294c9830543db6"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "cfg-if",
  "cfg_aliases",
  "libc",
@@ -2888,12 +2907,11 @@ dependencies = [
 
 [[package]]
 name = "nu-ansi-term"
-version = "0.46.0"
+version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
+checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "overload",
- "winapi",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -2919,18 +2937,19 @@ dependencies = [
 
 [[package]]
 name = "num_enum"
-version = "0.7.3"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e613fc340b2220f734a8595782c551f1250e969d87d3be1ae0579e8d4065179"
+checksum = "b1207a7e20ad57b847bbddc6776b968420d38292bbfe2089accff5e19e82454c"
 dependencies = [
  "num_enum_derive",
+ "rustversion",
 ]
 
 [[package]]
 name = "num_enum_derive"
-version = "0.7.3"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af1844ef2428cc3e1cb900be36181049ef3d3193c63e43026cfe202983b27a56"
+checksum = "ff32365de1b6743cb203b710788263c44a03de03802daf96092f2da4fe6ba4d7"
 dependencies = [
  "proc-macro-crate",
  "proc-macro2",
@@ -2969,7 +2988,7 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e4e89ad9e3d7d297152b17d39ed92cd50ca8063a89a9fa569046d41568891eff"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "block2",
  "libc",
  "objc2",
@@ -2985,7 +3004,7 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "74dd3b56391c7a0596a295029734d3c1c5e7e510a4cb30245f8221ccea96b009"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "block2",
  "objc2",
  "objc2-core-location",
@@ -3009,7 +3028,7 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "617fbf49e071c178c0b24c080767db52958f716d9eabdf0890523aeae54773ef"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "block2",
  "objc2",
  "objc2-foundation",
@@ -3017,11 +3036,11 @@ dependencies = [
 
 [[package]]
 name = "objc2-core-foundation"
-version = "0.3.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c10c2894a6fed806ade6027bcd50662746363a9589d3ec9d9bef30a4e4bc166"
+checksum = "2a180dd8642fa45cdb7dd721cd4c11b1cadd4929ce112ebd8b9f5803cc79d536"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
 ]
 
 [[package]]
@@ -3060,7 +3079,7 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0ee638a5da3799329310ad4cfa62fbf045d5f56e3ef5ba4149e7452dcf89d5a8"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "block2",
  "dispatch",
  "libc",
@@ -3085,7 +3104,7 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dd0cba1276f6023976a406a14ffa85e1fdd19df6b0f737b063b95f6c8c7aadd6"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "block2",
  "objc2",
  "objc2-foundation",
@@ -3097,7 +3116,7 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e42bee7bff906b14b167da2bac5efe6b6a07e6f7c0a21a7308d40c960242dc7a"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "block2",
  "objc2",
  "objc2-foundation",
@@ -3120,7 +3139,7 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b8bb46798b20cd6b91cbd113524c490f1686f4c4e8f49502431415f3512e2b6f"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "block2",
  "objc2",
  "objc2-cloud-kit",
@@ -3152,7 +3171,7 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "76cfcbf642358e8689af64cee815d139339f3ed8ad05103ed5eaf73db8d84cb3"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "block2",
  "objc2",
  "objc2-core-location",
@@ -3225,12 +3244,6 @@ dependencies = [
  "num-traits",
 ]
 
-[[package]]
-name = "overload"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
-
 [[package]]
 name = "parking"
 version = "2.2.1"
@@ -3239,9 +3252,9 @@ checksum = "f38d5652c16fde515bb1ecef450ab0f6a219d619a7274976324d5e377f7dceba"
 
 [[package]]
 name = "parking_lot"
-version = "0.12.4"
+version = "0.12.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70d58bf43669b5795d1576d0641cfb6fbb2057bf629506267a92807158584a13"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
 dependencies = [
  "lock_api",
  "parking_lot_core",
@@ -3249,15 +3262,15 @@ dependencies = [
 
 [[package]]
 name = "parking_lot_core"
-version = "0.9.11"
+version = "0.9.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc838d2a56b5b1a6c25f55575dfc605fabb63bb2365f6c2353ef9159aa69e4a5"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
 dependencies = [
  "cfg-if",
  "libc",
- "redox_syscall 0.5.12",
+ "redox_syscall 0.5.18",
  "smallvec",
- "windows-targets 0.52.6",
+ "windows-link",
 ]
 
 [[package]]
@@ -3268,9 +3281,9 @@ checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 
 [[package]]
 name = "percent-encoding"
-version = "2.3.1"
+version = "2.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
 
 [[package]]
 name = "petgraph"
@@ -3329,11 +3342,11 @@ checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
 
 [[package]]
 name = "png"
-version = "0.17.16"
+version = "0.18.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82151a2fc869e011c153adc57cf2789ccb8d9906ce52c0b39a6b5697749d7526"
+checksum = "97baced388464909d42d89643fe4361939af9b7ce7a31ee32a168f832a70f2a0"
 dependencies = [
- "bitflags 1.3.2",
+ "bitflags 2.10.0",
  "crc32fast",
  "fdeflate",
  "flate2",
@@ -3342,17 +3355,16 @@ dependencies = [
 
 [[package]]
 name = "polling"
-version = "3.8.0"
+version = "3.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b53a684391ad002dd6a596ceb6c74fd004fdce75f4be2e3f615068abbea5fd50"
+checksum = "5d0e4f59085d47d8241c88ead0f274e8a0cb551f3625263c05eb8dd897c34218"
 dependencies = [
  "cfg-if",
  "concurrent-queue",
  "hermit-abi",
  "pin-project-lite",
- "rustix 1.0.7",
- "tracing",
- "windows-sys 0.59.0",
+ "rustix 1.1.2",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -3399,9 +3411,9 @@ checksum = "e8cf8e6a8aa66ce33f63993ffc4ea4271eb5b0530a9002db8455ea6050c77bfa"
 
 [[package]]
 name = "prettyplease"
-version = "0.2.33"
+version = "0.2.37"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dee91521343f4c5c6a63edd65e54f31f5c92fe8978c40a4282f8372194c6a7d"
+checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b"
 dependencies = [
  "proc-macro2",
  "syn",
@@ -3409,42 +3421,51 @@ dependencies = [
 
 [[package]]
 name = "proc-macro-crate"
-version = "3.3.0"
+version = "3.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edce586971a4dfaa28950c6f18ed55e0406c1ab88bbce2c6f6293a7aaba73d35"
+checksum = "219cb19e96be00ab2e37d6e299658a0cfa83e52429179969b0f0121b4ac46983"
 dependencies = [
- "toml_edit",
+ "toml_edit 0.23.7",
 ]
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.95"
+version = "1.0.103"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02b3e5e68a3a1a02aad3ec490a98007cbc13c37cbe84a3cd7b8e406d76e7f778"
+checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "profiling"
-version = "1.0.16"
+version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "afbdc74edc00b6f6a218ca6a5364d6226a259d4b8ea1af4a0ea063f27e179f4d"
+checksum = "3eb8486b569e12e2c32ad3e204dbaba5e4b5b216e9367044f25f1dba42341773"
+
+[[package]]
+name = "pxfm"
+version = "0.1.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a3cbdf373972bf78df4d3b518d07003938e2c7d1fb5891e55f9cb6df57009d84"
+dependencies = [
+ "num-traits",
+]
 
 [[package]]
 name = "quote"
-version = "1.0.40"
+version = "1.0.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1885c039570dc00dcb4ff087a89e185fd56bae234ddc7f056a945bf36467248d"
+checksum = "ce25767e7b499d1b604768e7cde645d14cc8584231ea6b295e9c9eb22c02e1d1"
 dependencies = [
  "proc-macro2",
 ]
 
 [[package]]
 name = "r-efi"
-version = "5.2.0"
+version = "5.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74765f6d916ee2faa39bc8e68e4f3ed8949b48cccdac59983d287a7cb71ce9c5"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
 
 [[package]]
 name = "radsort"
@@ -3465,9 +3486,9 @@ dependencies = [
 
 [[package]]
 name = "rand"
-version = "0.9.1"
+version = "0.9.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9fbfd9d094a40bf3ae768db9361049ace4c0e04a4fd6b359518bd7b73a73dd97"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
 dependencies = [
  "rand_chacha 0.9.0",
  "rand_core 0.9.3",
@@ -3508,7 +3529,7 @@ version = "0.9.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
 dependencies = [
- "getrandom 0.3.3",
+ "getrandom 0.3.4",
 ]
 
 [[package]]
@@ -3529,9 +3550,9 @@ checksum = "c3d6831663a5098ea164f89cff59c6284e95f4e3c76ce9848d4529f5ccca9bde"
 
 [[package]]
 name = "rangemap"
-version = "1.5.1"
+version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f60fcc7d6849342eff22c4350c8b9a989ee8ceabc4b481253e8946b9fe83d684"
+checksum = "f93e7e49bb0bf967717f7bd674458b3d6b0c5f48ec7e3038166026a69fc22223"
 
 [[package]]
 name = "raw-window-handle"
@@ -3541,9 +3562,9 @@ checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539"
 
 [[package]]
 name = "read-fonts"
-version = "0.29.3"
+version = "0.35.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04ca636dac446b5664bd16c069c00a9621806895b8bb02c2dc68542b23b8f25d"
+checksum = "6717cf23b488adf64b9d711329542ba34de147df262370221940dfabc2c91358"
 dependencies = [
  "bytemuck",
  "font-types",
@@ -3566,56 +3587,41 @@ dependencies = [
 
 [[package]]
 name = "redox_syscall"
-version = "0.5.12"
+version = "0.5.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "928fca9cf2aa042393a8325b9ead81d2f0df4cb12e1e24cef072922ccd99c5af"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
 ]
 
 [[package]]
 name = "regex"
-version = "1.11.1"
+version = "1.12.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
+checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-automata 0.4.9",
- "regex-syntax 0.8.5",
+ "regex-automata",
+ "regex-syntax",
 ]
 
 [[package]]
 name = "regex-automata"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
-dependencies = [
- "regex-syntax 0.6.29",
-]
-
-[[package]]
-name = "regex-automata"
-version = "0.4.9"
+version = "0.4.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "809e8dc61f6de73b46c85f4c96486310fe304c434cfa43669d7b40f711150908"
+checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c"
 dependencies = [
  "aho-corasick",
  "memchr",
- "regex-syntax 0.8.5",
+ "regex-syntax",
 ]
 
 [[package]]
 name = "regex-syntax"
-version = "0.6.29"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
-
-[[package]]
-name = "regex-syntax"
-version = "0.8.5"
+version = "0.8.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
+checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
 
 [[package]]
 name = "renderdoc-sys"
@@ -3640,7 +3646,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b91f7eff05f748767f183df4320a63d6936e9c6107d97c9e6bdd9784f4289c94"
 dependencies = [
  "base64 0.21.7",
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "serde",
  "serde_derive",
 ]
@@ -3669,7 +3675,7 @@ version = "0.38.44"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "fdb5bc1ae2baa591800df16c9ca78619bf65c0488b41b96ccec5d11220d8c154"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "errno",
  "libc",
  "linux-raw-sys 0.4.15",
@@ -3678,22 +3684,22 @@ dependencies = [
 
 [[package]]
 name = "rustix"
-version = "1.0.7"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c71e83d6afe7ff64890ec6b71d6a69bb8a610ab78ce364b3352876bb4c801266"
+checksum = "cd15f8a2c5551a84d56efdc1cd049089e409ac19a3072d5037a17fd70719ff3e"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "errno",
  "libc",
- "linux-raw-sys 0.9.4",
- "windows-sys 0.59.0",
+ "linux-raw-sys 0.11.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
 name = "rustversion"
-version = "1.0.21"
+version = "1.0.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a0d197bd2c9dc6e53b84da9556a69ba4cdfab8619eb41a8bd1cc2027a0f6b1d"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
 
 [[package]]
 name = "rustybuzz"
@@ -3701,7 +3707,7 @@ version = "0.14.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "cfb9cf8877777222e4a3bc7eb247e398b56baba500c38c1c46842431adc8b55c"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "bytemuck",
  "libm",
  "smallvec",
@@ -3744,9 +3750,9 @@ checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
 
 [[package]]
 name = "self_cell"
-version = "1.2.0"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f7d95a54511e0c7be3f51e8867aa8cf35148d7b9445d44de2f943e2b206e749"
+checksum = "16c2f82143577edb4921b71ede051dac62ca3c16084e918bf7b40c96ae10eb33"
 
 [[package]]
 name = "send_wrapper"
@@ -3756,18 +3762,28 @@ checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73"
 
 [[package]]
 name = "serde"
-version = "1.0.219"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.219"
+version = "1.0.228"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3776,14 +3792,15 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.140"
+version = "1.0.145"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373"
+checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c"
 dependencies = [
  "itoa",
  "memchr",
  "ryu",
  "serde",
+ "serde_core",
 ]
 
 [[package]]
@@ -3809,9 +3826,9 @@ checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe"
 
 [[package]]
 name = "skrifa"
-version = "0.31.3"
+version = "0.37.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbeb4ca4399663735553a09dd17ce7e49a0a0203f03b706b39628c4d913a8607"
+checksum = "8c31071dedf532758ecf3fed987cdb4bd9509f900e026ab684b4ecb81ea49841"
 dependencies = [
  "bytemuck",
  "read-fonts",
@@ -3819,12 +3836,9 @@ dependencies = [
 
 [[package]]
 name = "slab"
-version = "0.4.9"
+version = "0.4.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
-dependencies = [
- "autocfg",
-]
+checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
 
 [[package]]
 name = "slotmap"
@@ -3865,14 +3879,14 @@ version = "0.3.0+sdk-1.3.268.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "eda41003dc44290527a59b13432d4a0379379fa074b70174882adfbdfd917844"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
 ]
 
 [[package]]
 name = "stable_deref_trait"
-version = "1.2.0"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
 
 [[package]]
 name = "stackfuture"
@@ -3916,9 +3930,9 @@ checksum = "0193cc4331cfd2f3d2011ef287590868599a2f33c3e69bc22c1a3d3acf9e02fb"
 
 [[package]]
 name = "swash"
-version = "0.2.5"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f745de914febc7c9ab4388dfaf94bbc87e69f57bb41133a9b0c84d4be49856f3"
+checksum = "47846491253e976bdd07d0f9cc24b7daf24720d11309302ccbbc6e6b6e53550a"
 dependencies = [
  "skrifa",
  "yazi",
@@ -3927,9 +3941,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.102"
+version = "2.0.108"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6397daf94fa90f058bd0fd88429dd9e5738999cca8d701813c80723add80462"
+checksum = "da58917d35242480a05c2897064da0a80589a2a0476c9a3f2fdc83b53502e917"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -3979,6 +3993,27 @@ dependencies = [
  "winapi-util",
 ]
 
+[[package]]
+name = "test-log"
+version = "0.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e33b98a582ea0be1168eba097538ee8dd4bbe0f2b01b22ac92ea30054e5be7b"
+dependencies = [
+ "test-log-macros",
+ "tracing-subscriber",
+]
+
+[[package]]
+name = "test-log-macros"
+version = "0.2.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "451b374529930d7601b1eef8d32bc79ae870b6079b069401709c2a8bf9e75f36"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "thiserror"
 version = "1.0.69"
@@ -3990,11 +4025,11 @@ dependencies = [
 
 [[package]]
 name = "thiserror"
-version = "2.0.12"
+version = "2.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708"
+checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8"
 dependencies = [
- "thiserror-impl 2.0.12",
+ "thiserror-impl 2.0.17",
 ]
 
 [[package]]
@@ -4010,9 +4045,9 @@ dependencies = [
 
 [[package]]
 name = "thiserror-impl"
-version = "2.0.12"
+version = "2.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d"
+checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4021,19 +4056,18 @@ dependencies = [
 
 [[package]]
 name = "thread_local"
-version = "1.1.8"
+version = "1.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c"
+checksum = "f60246a4944f24f6e018aa17cdeffb7818b76356965d03b07d6a9886e8962185"
 dependencies = [
  "cfg-if",
- "once_cell",
 ]
 
 [[package]]
 name = "tinyvec"
-version = "1.9.0"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09b3661f17e86524eccd4371ab0429194e0d7c008abb45f7a7495b1719463c71"
+checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa"
 dependencies = [
  "tinyvec_macros",
 ]
@@ -4050,6 +4084,15 @@ version = "0.6.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "22cddaf88f4fbc13c51aebbf5f8eceb5c7c5a9da2ac40a13519eb5b0a0e8f11c"
 
+[[package]]
+name = "toml_datetime"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2cdb639ebbc97961c51720f858597f7f24c4fc295327923af55b74c3c724533"
+dependencies = [
+ "serde_core",
+]
+
 [[package]]
 name = "toml_edit"
 version = "0.22.27"
@@ -4057,7 +4100,28 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
 dependencies = [
  "indexmap",
- "toml_datetime",
+ "toml_datetime 0.6.11",
+ "winnow",
+]
+
+[[package]]
+name = "toml_edit"
+version = "0.23.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6485ef6d0d9b5d0ec17244ff7eb05310113c3f316f2d14200d4de56b3cb98f8d"
+dependencies = [
+ "indexmap",
+ "toml_datetime 0.7.3",
+ "toml_parser",
+ "winnow",
+]
+
+[[package]]
+name = "toml_parser"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0cbe268d35bdb4bb5a56a2de88d0ad0eb70af5384a99d648cd4b3d04039800e"
+dependencies = [
  "winnow",
 ]
 
@@ -4074,9 +4138,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-attributes"
-version = "0.1.29"
+version = "0.1.30"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b1ffbcf9c6f6b99d386e7444eb608ba646ae452a36b39737deb9663b610f662"
+checksum = "81383ab64e72a7a8b8e13130c49e3dab29def6d0c7d76a03087b3cf71c5c6903"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4121,14 +4185,14 @@ dependencies = [
 
 [[package]]
 name = "tracing-subscriber"
-version = "0.3.19"
+version = "0.3.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8189decb5ac0fa7bc8b96b7cb9b2701d60d48805aca84a238004d665fcc4008"
+checksum = "2054a14f5307d601f88daf0553e1cbf472acc4f2c51afab632431cdcd72124d5"
 dependencies = [
  "matchers",
  "nu-ansi-term",
  "once_cell",
- "regex",
+ "regex-automata",
  "sharded-slab",
  "smallvec",
  "thread_local",
@@ -4162,9 +4226,9 @@ checksum = "2c591d83f69777866b9126b24c6dd9a18351f177e49d625920d19f989fd31cf8"
 
 [[package]]
 name = "twox-hash"
-version = "2.1.1"
+version = "2.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b907da542cbced5261bd3256de1b3a1bf340a3d37f93425a07362a1d687de56"
+checksum = "9ea3136b675547379c4bd395ca6b938e5ad3c3d20fad76e7fe85f9e0d011419c"
 
 [[package]]
 name = "typeid"
@@ -4172,6 +4236,12 @@ version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bc7d623258602320d5c55d1bc22793b57daff0ec7efc270ea7d55ce1d5f5471c"
 
+[[package]]
+name = "typewit"
+version = "1.14.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8c1ae7cc0fdb8b842d65d127cb981574b0d2b249b74d1c7a2986863dc134f71"
+
 [[package]]
 name = "unicode-bidi"
 version = "0.3.18"
@@ -4192,9 +4262,9 @@ checksum = "1df77b101bcc4ea3d78dafc5ad7e4f58ceffe0b2b16bf446aeb50b6cb4157656"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.18"
+version = "1.0.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
+checksum = "462eeb75aeb73aea900253ce739c8e18a67423fadf006037cd3ff27e82748a06"
 
 [[package]]
 name = "unicode-linebreak"
@@ -4234,11 +4304,11 @@ checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
 
 [[package]]
 name = "uuid"
-version = "1.17.0"
+version = "1.18.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3cf4199d1e5d15ddd86a694e4d0dffa9c323ce759fea589f00fef9d81cc1931d"
+checksum = "2f87b8aa10b915a06587d0dec516c282ff295b475d94abf425d62b57710070a2"
 dependencies = [
- "getrandom 0.3.3",
+ "getrandom 0.3.4",
  "js-sys",
  "serde",
  "wasm-bindgen",
@@ -4290,31 +4360,32 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
 
 [[package]]
-name = "wasi"
-version = "0.14.2+wasi-0.2.4"
+name = "wasip2"
+version = "1.0.1+wasi-0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9683f9a5a998d873c0d21fcbe3c083009670149a8fab228644b8bd36b2c48cb3"
+checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7"
 dependencies = [
- "wit-bindgen-rt",
+ "wit-bindgen",
 ]
 
 [[package]]
 name = "wasm-bindgen"
-version = "0.2.100"
+version = "0.2.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1edc8929d7499fc4e8f0be2262a241556cfc54a0bea223790e71446f2aab1ef5"
+checksum = "c1da10c01ae9f1ae40cbfac0bac3b1e724b320abfcf52229f80b547c0d250e2d"
 dependencies = [
  "cfg-if",
  "once_cell",
  "rustversion",
  "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
 ]
 
 [[package]]
 name = "wasm-bindgen-backend"
-version = "0.2.100"
+version = "0.2.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2f0a0651a5c2bc21487bde11ee802ccaf4c51935d0d3d42a6101f98161700bc6"
+checksum = "671c9a5a66f49d8a47345ab942e2cb93c7d1d0339065d4f8139c486121b43b19"
 dependencies = [
  "bumpalo",
  "log",
@@ -4326,9 +4397,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-futures"
-version = "0.4.50"
+version = "0.4.54"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "555d470ec0bc3bb57890405e5d4322cc9ea83cebb085523ced7be4144dac1e61"
+checksum = "7e038d41e478cc73bae0ff9b36c60cff1c98b8f38f8d7e8061e79ee63608ac5c"
 dependencies = [
  "cfg-if",
  "js-sys",
@@ -4339,9 +4410,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro"
-version = "0.2.100"
+version = "0.2.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fe63fc6d09ed3792bd0897b314f53de8e16568c2b3f7982f468c0bf9bd0b407"
+checksum = "7ca60477e4c59f5f2986c50191cd972e3a50d8a95603bc9434501cf156a9a119"
 dependencies = [
  "quote",
  "wasm-bindgen-macro-support",
@@ -4349,9 +4420,9 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-macro-support"
-version = "0.2.100"
+version = "0.2.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8ae87ea40c9f689fc23f209965b6fb8a99ad69aeeb0231408be24920604395de"
+checksum = "9f07d2f20d4da7b26400c9f4a0511e6e0345b040694e8a75bd41d578fa4421d7"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4362,18 +4433,18 @@ dependencies = [
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.100"
+version = "0.2.104"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a05d73b933a847d6cccdda8f838a22ff101ad9bf93e33684f39c1f5f0eece3d"
+checksum = "bad67dc8b2a1a6e5448428adec4c3e84c43e561d8c9ee8a9e5aabeb193ec41d1"
 dependencies = [
  "unicode-ident",
 ]
 
 [[package]]
 name = "web-sys"
-version = "0.3.77"
+version = "0.3.81"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33b6dd2ef9186f1f2072e409e99cd22a975331a6b3591b12c764e0e55c60d5d2"
+checksum = "9367c417a924a74cae129e6a2ae3b47fabb1f8995595ab474029da749a8be120"
 dependencies = [
  "js-sys",
  "wasm-bindgen",
@@ -4396,7 +4467,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6b0b3436f0729f6cdf2e6e9201f3d39dc95813fad61d826c1ed07918b4539353"
 dependencies = [
  "arrayvec",
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "cfg_aliases",
  "document-features",
  "js-sys",
@@ -4423,7 +4494,7 @@ checksum = "7f0aa306497a238d169b9dc70659105b4a096859a34894544ca81719242e1499"
 dependencies = [
  "arrayvec",
  "bit-vec 0.8.0",
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "cfg_aliases",
  "document-features",
  "indexmap",
@@ -4435,7 +4506,7 @@ dependencies = [
  "raw-window-handle",
  "rustc-hash 1.1.0",
  "smallvec",
- "thiserror 2.0.12",
+ "thiserror 2.0.17",
  "wgpu-hal",
  "wgpu-types",
 ]
@@ -4450,7 +4521,7 @@ dependencies = [
  "arrayvec",
  "ash",
  "bit-set 0.8.0",
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "block",
  "bytemuck",
  "cfg_aliases",
@@ -4478,7 +4549,7 @@ dependencies = [
  "renderdoc-sys",
  "rustc-hash 1.1.0",
  "smallvec",
- "thiserror 2.0.12",
+ "thiserror 2.0.17",
  "wasm-bindgen",
  "web-sys",
  "wgpu-types",
@@ -4492,7 +4563,7 @@ version = "24.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "50ac044c0e76c03a0378e7786ac505d010a873665e2d51383dcff8dd227dc69c"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "js-sys",
  "log",
  "serde",
@@ -4517,11 +4588,11 @@ checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
 
 [[package]]
 name = "winapi-util"
-version = "0.1.9"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf221c93e13a30d793f7645a0e7762c55d169dbb0a49671918a2319d289b10bb"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
@@ -4562,24 +4633,23 @@ dependencies = [
 
 [[package]]
 name = "windows"
-version = "0.61.2"
+version = "0.62.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2b85ac982d24496e0b49912479da8a89c0ba7b1d8bf6de49df12af42e94b325"
+checksum = "527fadee13e0c05939a6a05d5bd6eec6cd2e3dbd648b9f8e447c6518133d8580"
 dependencies = [
  "windows-collections",
- "windows-core 0.61.2",
+ "windows-core 0.62.2",
  "windows-future",
- "windows-link",
  "windows-numerics",
 ]
 
 [[package]]
 name = "windows-collections"
-version = "0.2.0"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3beeceb5e5cfd9eb1d76b381630e82c4241ccd0d27f1a39ed41b2760b255c5e8"
+checksum = "23b2d95af1a8a14a3c7367e1ed4fc9c20e0a26e79551b1454d72583c97cc6610"
 dependencies = [
- "windows-core 0.61.2",
+ "windows-core 0.62.2",
 ]
 
 [[package]]
@@ -4619,24 +4689,24 @@ dependencies = [
 
 [[package]]
 name = "windows-core"
-version = "0.61.2"
+version = "0.62.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0fdd3ddb90610c7638aa2b3a3ab2904fb9e5cdbecc643ddb3647212781c4ae3"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
 dependencies = [
- "windows-implement 0.60.0",
- "windows-interface 0.59.1",
+ "windows-implement 0.60.2",
+ "windows-interface 0.59.3",
  "windows-link",
- "windows-result 0.3.4",
- "windows-strings 0.4.2",
+ "windows-result 0.4.1",
+ "windows-strings 0.5.1",
 ]
 
 [[package]]
 name = "windows-future"
-version = "0.2.1"
+version = "0.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc6a41e98427b19fe4b73c550f060b59fa592d7d686537eebf9385621bfbad8e"
+checksum = "e1d6f90251fe18a279739e78025bd6ddc52a7e22f921070ccdc67dde84c605cb"
 dependencies = [
- "windows-core 0.61.2",
+ "windows-core 0.62.2",
  "windows-link",
  "windows-threading",
 ]
@@ -4665,9 +4735,9 @@ dependencies = [
 
 [[package]]
 name = "windows-implement"
-version = "0.60.0"
+version = "0.60.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a47fddd13af08290e67f4acabf4b459f647552718f683a7b415d290ac744a836"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4698,9 +4768,9 @@ dependencies = [
 
 [[package]]
 name = "windows-interface"
-version = "0.59.1"
+version = "0.59.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd9211b69f8dcdfa817bfd14bf1c97c9188afa36f4750130fcdf3f400eca9fa8"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -4709,17 +4779,17 @@ dependencies = [
 
 [[package]]
 name = "windows-link"
-version = "0.1.2"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3bfe459f85da17560875b8bf1423d6f113b7a87a5d942e7da0ac71be7c61f8b"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
 
 [[package]]
 name = "windows-numerics"
-version = "0.2.0"
+version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9150af68066c4c5c07ddc0ce30421554771e528bde427614c61038bc2c92c2b1"
+checksum = "6e2e40844ac143cdb44aead537bbf727de9b044e107a0f1220392177d15b0f26"
 dependencies = [
- "windows-core 0.61.2",
+ "windows-core 0.62.2",
  "windows-link",
 ]
 
@@ -4743,9 +4813,9 @@ dependencies = [
 
 [[package]]
 name = "windows-result"
-version = "0.3.4"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56f42bd332cc6c8eac5af113fc0c1fd6a8fd2aa08a0119358686e5160d0586c6"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
 dependencies = [
  "windows-link",
 ]
@@ -4762,9 +4832,9 @@ dependencies = [
 
 [[package]]
 name = "windows-strings"
-version = "0.4.2"
+version = "0.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56e6c93f3a0c3b36176cb1327a4958a0353d5d166c2a35cb268ace15e91d3b57"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
 dependencies = [
  "windows-link",
 ]
@@ -4796,6 +4866,15 @@ dependencies = [
  "windows-targets 0.52.6",
 ]
 
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
 [[package]]
 name = "windows-targets"
 version = "0.42.2"
@@ -4811,21 +4890,6 @@ dependencies = [
  "windows_x86_64_msvc 0.42.2",
 ]
 
-[[package]]
-name = "windows-targets"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
-dependencies = [
- "windows_aarch64_gnullvm 0.48.5",
- "windows_aarch64_msvc 0.48.5",
- "windows_i686_gnu 0.48.5",
- "windows_i686_msvc 0.48.5",
- "windows_x86_64_gnu 0.48.5",
- "windows_x86_64_gnullvm 0.48.5",
- "windows_x86_64_msvc 0.48.5",
-]
-
 [[package]]
 name = "windows-targets"
 version = "0.52.6"
@@ -4835,34 +4899,18 @@ dependencies = [
  "windows_aarch64_gnullvm 0.52.6",
  "windows_aarch64_msvc 0.52.6",
  "windows_i686_gnu 0.52.6",
- "windows_i686_gnullvm 0.52.6",
+ "windows_i686_gnullvm",
  "windows_i686_msvc 0.52.6",
  "windows_x86_64_gnu 0.52.6",
  "windows_x86_64_gnullvm 0.52.6",
  "windows_x86_64_msvc 0.52.6",
 ]
 
-[[package]]
-name = "windows-targets"
-version = "0.53.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "30357ec391cde730f8fbfcdc29adc47518b06504528df977ab5af02ef23fdee9"
-dependencies = [
- "windows_aarch64_gnullvm 0.53.0",
- "windows_aarch64_msvc 0.53.0",
- "windows_i686_gnu 0.53.0",
- "windows_i686_gnullvm 0.53.0",
- "windows_i686_msvc 0.53.0",
- "windows_x86_64_gnu 0.53.0",
- "windows_x86_64_gnullvm 0.53.0",
- "windows_x86_64_msvc 0.53.0",
-]
-
 [[package]]
 name = "windows-threading"
-version = "0.1.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b66463ad2e0ea3bbf808b7f1d371311c80e115c0b71d60efc142cafbcfb057a6"
+checksum = "3949bd5b99cafdf1c7ca86b43ca564028dfe27d66958f2470940f73d86d75b37"
 dependencies = [
  "windows-link",
 ]
@@ -4873,189 +4921,99 @@ version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
 
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
-
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
 
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "86b8d5f90ddd19cb4a147a5fa63ca848db3df085e25fee3cc10b39b6eebae764"
-
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
 
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
-
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
 
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7651a1f62a11b8cbd5e0d42526e55f2c99886c77e007179efff86c2b137e66c"
-
 [[package]]
 name = "windows_i686_gnu"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
 
-[[package]]
-name = "windows_i686_gnu"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
-
 [[package]]
 name = "windows_i686_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
 
-[[package]]
-name = "windows_i686_gnu"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1dc67659d35f387f5f6c479dc4e28f1d4bb90ddd1a5d3da2e5d97b42d6272c3"
-
 [[package]]
 name = "windows_i686_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
 
-[[package]]
-name = "windows_i686_gnullvm"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ce6ccbdedbf6d6354471319e781c0dfef054c81fbc7cf83f338a4296c0cae11"
-
 [[package]]
 name = "windows_i686_msvc"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
 
-[[package]]
-name = "windows_i686_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
-
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
 
-[[package]]
-name = "windows_i686_msvc"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "581fee95406bb13382d2f65cd4a908ca7b1e4c2f1917f143ba16efe98a589b5d"
-
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
 
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
-
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
 
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2e55b5ac9ea33f2fc1716d1742db15574fd6fc8dadc51caab1c16a3d3b4190ba"
-
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
 
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
-
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
 
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a6e035dd0599267ce1ee132e51c27dd29437f63325753051e71dd9e42406c57"
-
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.42.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
 
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
-
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.53.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "271414315aff87387382ec3d271b52d7ae78726f5d44ac98b4f4030c91880486"
-
 [[package]]
 name = "winit"
-version = "0.30.11"
+version = "0.30.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4409c10174df8779dc29a4788cac85ed84024ccbc1743b776b21a520ee1aaf4"
+checksum = "c66d4b9ed69c4009f6321f762d6e61ad8a2389cd431b97cb1e146812e9e6c732"
 dependencies = [
  "android-activity",
  "atomic-waker",
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "block2",
  "bytemuck",
  "calloop",
@@ -5093,21 +5051,18 @@ dependencies = [
 
 [[package]]
 name = "winnow"
-version = "0.7.11"
+version = "0.7.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74c7b26e3480b707944fc872477815d29a8e429d2f93a1ce000f5fa84a15cbcd"
+checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
-name = "wit-bindgen-rt"
-version = "0.39.0"
+name = "wit-bindgen"
+version = "0.46.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f42320e61fe2cfd34354ecb597f86f413484a798ba44a8ca1165c58d42da6c1"
-dependencies = [
- "bitflags 2.9.1",
-]
+checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
 
 [[package]]
 name = "x11-dl"
@@ -5122,24 +5077,24 @@ dependencies = [
 
 [[package]]
 name = "x11rb"
-version = "0.13.1"
+version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d91ffca73ee7f68ce055750bf9f6eca0780b8c85eff9bc046a3b0da41755e12"
+checksum = "9993aa5be5a26815fe2c3eacfc1fde061fc1a1f094bf1ad2a18bf9c495dd7414"
 dependencies = [
  "as-raw-xcb-connection",
  "gethostname",
  "libc",
  "libloading",
  "once_cell",
- "rustix 0.38.44",
+ "rustix 1.1.2",
  "x11rb-protocol",
 ]
 
 [[package]]
 name = "x11rb-protocol"
-version = "0.13.1"
+version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec107c4503ea0b4a98ef47356329af139c0a4f7750e621cf2973cd3385ebcb3d"
+checksum = "ea6fc2961e4ef194dcbfe56bb845534d0dc8098940c7e5c012a258bfec6701bd"
 
 [[package]]
 name = "xkbcommon-dl"
@@ -5147,7 +5102,7 @@ version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d039de8032a9a8856a6be89cea3e5d12fdd82306ab7c94d74e6deab2460651c5"
 dependencies = [
- "bitflags 2.9.1",
+ "bitflags 2.10.0",
  "dlib",
  "log",
  "once_cell",
@@ -5162,9 +5117,9 @@ checksum = "b9cc00251562a284751c9973bace760d86c0276c471b4be569fe6b068ee97a56"
 
 [[package]]
 name = "xml-rs"
-version = "0.8.26"
+version = "0.8.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a62ce76d9b56901b19a74f19431b0d8b3bc7ca4ad685a746dfd78ca8f4fc6bda"
+checksum = "6fd8403733700263c6eb89f192880191f1b83e332f7a20371ddcf421c4a337c7"
 
 [[package]]
 name = "yazi"
@@ -5180,18 +5135,18 @@ checksum = "6df3dc4292935e51816d896edcd52aa30bc297907c26167fec31e2b0c6a32524"
 
 [[package]]
 name = "zerocopy"
-version = "0.8.25"
+version = "0.8.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1702d9583232ddb9174e01bb7c15a2ab8fb1bc6f227aa1233858c351a3ba0cb"
+checksum = "0894878a5fa3edfd6da3f88c4805f4c8558e2b996227a3d864f47fe11e38282c"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.8.25"
+version = "0.8.27"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28a6e20d751156648aa063f3800b706ee209a32c0b4d9f24be3d980b01be55ef"
+checksum = "88d2b8d9c68ad2b9e4340d7832716a4d21a22a1154777ad56ea55c51a9cf3831"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index 1a68172..da7aa19 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -63,8 +63,9 @@ web = [
 deployed_wasm_example = []
 
 [dev-dependencies]
-bevy = "0.16"
+bevy = { version = "0.16", features = ["track_location"] }
 rand = "0.9"
+test-log = { version = "0.2", default-features = false, features = ["trace"] }
 
 [target.'cfg(target_arch = "wasm32")'.dev-dependencies.getrandom]
 version = "0.3"
diff --git a/README.md b/README.md
index 97852c7..07fd70a 100644
--- a/README.md
+++ b/README.md
@@ -88,6 +88,7 @@ fn ui_root() -> JonmoBuilder {
             flex_direction: FlexDirection::Row,
             column_gap: Val::Px(15.0),
             align_items: AlignItems::Center,
+            padding: UiRect::all(Val::Px(25.)),
             ..default()
         })
         .insert(Counter(0))
@@ -117,7 +118,7 @@ fn ui_root() -> JonmoBuilder {
                         // `.dedupe()` ensures the rest of the chain only runs when the counter's value *actually
                         // changes*, preventing redundant updates every frame.
                         .dedupe()
-                        // `Text` expects a `String`
+                        // `Text` expects a `String` and `.to_string` expects a reference
                         .map_in_ref(ToString::to_string)
                         .map_in(Text)
                         // `component_signal` expects an `Option<Component>`. If the signal produces `None`, the
diff --git a/examples/counter.rs b/examples/counter.rs
index fa62492..f61543c 100644
--- a/examples/counter.rs
+++ b/examples/counter.rs
@@ -91,7 +91,7 @@ fn ui_root() -> JonmoBuilder {
                         // `.dedupe()` ensures the rest of the chain only runs when the counter's value *actually
                         // changes*, preventing redundant updates every frame.
                         .dedupe()
-                        // `Text` expects a `String`
+                        // `Text` expects a `String` and `.to_string` expects a reference
                         .map_in_ref(ToString::to_string)
                         .map_in(Text)
                         // `component_signal` expects an `Option<Component>`. If the signal produces `None`, the
diff --git a/examples/filters.rs b/examples/filters.rs
index f498265..87e4bf0 100644
--- a/examples/filters.rs
+++ b/examples/filters.rs
@@ -9,8 +9,9 @@ use rand::{Rng, prelude::IndexedRandom};
 
 fn main() {
     let mut app = App::new();
-    let datas = MutableVec::from((0..12).map(|_| random_data()).collect::<Vec<_>>());
-    let rows = MutableVec::from((0..5).map(|_| ()).collect::<Vec<_>>());
+    let world = app.world_mut();
+    let datas = MutableVecBuilder::from((0..12).map(|_| random_data()).collect::<Vec<_>>()).spawn(world);
+    let rows = MutableVecBuilder::from((0..5).map(|_| ()).collect::<Vec<_>>()).spawn(world);
     app.add_plugins(examples_plugin)
         .insert_resource(Datas(datas.clone()))
         .insert_resource(Rows(rows.clone()))
@@ -112,9 +113,10 @@ fn ui(items: MutableVec<Data>, rows: MutableVec<()>) -> JonmoBuilder {
                 TextLayout::new_with_justify(JustifyText::Center),
             )))
             .child(button("+", -2.).apply(on_click(
-                |_: Trigger<Pointer<Click>>, datas: Res<Datas>, mut commands: Commands| {
-                    datas.0.write().insert(0, random_data());
-                    commands.queue(datas.0.flush());
+                |_: Trigger<Pointer<Click>>,
+                 datas: Res<Datas>,
+                 mut mutable_vec_datas: Query<&mut MutableVecData<_>>| {
+                    datas.0.write(&mut mutable_vec_datas).insert(0, random_data());
                 },
             )))
             .child(
@@ -148,9 +150,8 @@ fn ui(items: MutableVec<Data>, rows: MutableVec<()>) -> JonmoBuilder {
                 // BackgroundColor(Color::WHITE),
             ))
             .child(button("+", -2.).apply(on_click(
-                |_: Trigger<Pointer<Click>>, rows: Res<Rows>, mut commands: Commands| {
-                    rows.0.write().push(());
-                    commands.queue(rows.0.flush());
+                |_: Trigger<Pointer<Click>>, rows: Res<Rows>, mut mutable_vec_datas: Query<&mut MutableVecData<_>>| {
+                    rows.0.write(&mut mutable_vec_datas).push(());
                 },
             ))),
         ),
@@ -401,10 +402,12 @@ fn row(index: impl Signal<Item = Option<usize>>, items: MutableVec<Data>) -> Jon
         button("-", -3.)
             .component_signal(index.map_in(|index| index.map(Index)))
             .apply(on_click(
-                |click: Trigger<Pointer<Click>>, rows: Res<Rows>, indices: Query<&Index>, mut commands: Commands| {
+                |click: Trigger<Pointer<Click>>,
+                 rows: Res<Rows>,
+                 indices: Query<&Index>,
+                 mut mutable_vec_datas: Query<&mut MutableVecData<_>>| {
                     if let Ok(&Index(index)) = indices.get(click.target()) {
-                        rows.0.write().remove(index);
-                        commands.queue(rows.0.flush());
+                        rows.0.write(&mut mutable_vec_datas).remove(index);
                     }
                 },
             )),
@@ -501,19 +504,21 @@ fn item(index: impl Signal<Item = Option<usize>>, Data { number, color, shape }:
     ))
     .component_signal(index.map_in(|index| index.map(Index)))
     .apply(on_click(
-        |click: Trigger<Pointer<Click>>, datas: Res<Datas>, indices: Query<&Index>, mut commands: Commands| {
+        |click: Trigger<Pointer<Click>>,
+         datas: Res<Datas>,
+         indices: Query<&Index>,
+         mut mutable_vec_datas: Query<&mut MutableVecData<_>>| {
             if let Ok(&Index(index)) = indices.get(click.target()) {
-                datas.0.write().remove(index);
-                commands.queue(datas.0.flush());
+                datas.0.write(&mut mutable_vec_datas).remove(index);
             }
         },
     ))
-    .child(JonmoBuilder::from((
+    .child((
         Node::default(),
         Text::new(number.to_string()),
         TextColor(Color::BLACK),
         TextLayout::new_with_justify(JustifyText::Center),
-    )))
+    ))
 }
 
 fn camera(mut commands: Commands) {
diff --git a/examples/letters.rs b/examples/letters.rs
index 9abe56a..1dc0f16 100644
--- a/examples/letters.rs
+++ b/examples/letters.rs
@@ -12,11 +12,12 @@ use jonmo::prelude::*;
 
 fn main() {
     let mut app = App::new();
-    let letters = MutableBTreeMap::from(
+    let letters = MutableBTreeMapBuilder::from(
         ROWS.iter()
             .flat_map(|row| row.chars().map(|letter| (letter, LetterData::default())))
             .collect::<BTreeMap<_, _>>(),
-    );
+    )
+    .spawn(app.world_mut());
     app.add_plugins(examples_plugin)
         .insert_resource(Letters(letters.clone()))
         .add_systems(
@@ -178,7 +179,11 @@ fn letter(letter: char, data: impl Signal<Item = LetterData> + Clone) -> JonmoBu
     )
 }
 
-fn listen(keys: ResMut<ButtonInput<KeyCode>>, letters: Res<Letters>, mut commands: Commands) {
+fn listen(
+    keys: ResMut<ButtonInput<KeyCode>>,
+    letters: Res<Letters>,
+    mut mutable_btree_map_datas: Query<&mut MutableBTreeMapData<char, LetterData>>,
+) {
     let map = HashMap::from([
         (KeyCode::KeyA, 'a'),
         (KeyCode::KeyB, 'b'),
@@ -207,10 +212,9 @@ fn listen(keys: ResMut<ButtonInput<KeyCode>>, letters: Res<Letters>, mut command
         (KeyCode::KeyY, 'y'),
         (KeyCode::KeyZ, 'z'),
     ]);
-    let mut flush = false;
     for (key, char) in map.iter() {
         if keys.just_pressed(*key) {
-            let mut guard = letters.0.write();
+            let mut guard = letters.0.write(&mut mutable_btree_map_datas);
             guard.insert(
                 *char,
                 LetterData {
@@ -218,9 +222,8 @@ fn listen(keys: ResMut<ButtonInput<KeyCode>>, letters: Res<Letters>, mut command
                     count: guard.get(char).unwrap().count + 1,
                 },
             );
-            flush = true;
         } else if keys.just_released(*key) {
-            let mut guard = letters.0.write();
+            let mut guard = letters.0.write(&mut mutable_btree_map_datas);
             guard.insert(
                 *char,
                 LetterData {
@@ -228,12 +231,8 @@ fn listen(keys: ResMut<ButtonInput<KeyCode>>, letters: Res<Letters>, mut command
                     ..guard.get(char).unwrap().clone()
                 },
             );
-            flush = true;
         }
     }
-    if flush {
-        commands.queue(letters.0.flush());
-    }
 }
 
 fn camera(mut commands: Commands) {
diff --git a/examples/lifetimes.rs b/examples/lifetimes.rs
index ef94a4c..e0e47f8 100644
--- a/examples/lifetimes.rs
+++ b/examples/lifetimes.rs
@@ -21,13 +21,13 @@ use jonmo::prelude::*;
 
 fn main() {
     let mut app = App::new();
-
+    let world = app.world_mut();
     // 1. --- DATA SOURCE SETUP ---
     // `MutableVec` is the core reactive data source for lists in `jonmo`.
     // We initialize it with two random colors.
     // It's wrapped in an `Arc<RwLock<...>>` internally, so cloning it is cheap
     // and allows multiple systems to access and modify the same data.
-    let colors = MutableVec::from([random_color(), random_color()]);
+    let colors = MutableVecBuilder::from([random_color(), random_color()]).spawn(world);
 
     app.add_plugins(examples_plugin)
         // 2. --- RESOURCE MANAGEMENT ---
@@ -121,16 +121,14 @@ fn ui_root(colors: impl SignalVec<Item = Color>) -> JonmoBuilder {
             // button entity to listen for a `Click` event.
             world.entity_mut(entity).observe(
                 // This closure is the event handler that runs when the button is clicked.
-                move |_: Trigger<Pointer<Click>>, colors: Res<Colors>, mut commands: Commands| {
+                move |_: Trigger<Pointer<Click>>,
+                      colors: Res<Colors>,
+                      mut mutable_vec_datas: Query<&mut MutableVecData<_>>| {
                     // Try to get the `Index` component from the clicked entity.
                     // We found the index! Now we can mutate the central data source.
                     // `colors.0.write()` gets a write lock on the `MutableVec`.
-                    let mut guard = colors.0.write();
+                    let mut guard = colors.0.write(&mut mutable_vec_datas);
                     guard.insert(guard.len(), random_color());
-                    // IMPORTANT: After mutating a `MutableVec`, you must call `flush()`
-                    // to broadcast the changes to all listening signals.
-                    // We queue the flush command to be run at the end of the frame.
-                    commands.queue(colors.0.flush());
                 },
             );
         })
@@ -263,16 +261,12 @@ fn item(index: impl Signal<Item = Option<usize>> + Clone, color: Color) -> Jonmo
                 move |_: Trigger<Pointer<Click>>,
                       indices: Query<&Index>,
                       colors: Res<Colors>,
-                      mut commands: Commands| {
+                      mut mutable_vec_datas: Query<&mut MutableVecData<_>>| {
                     // Try to get the `Index` component from the clicked entity.
                     if let Ok(&Index(index)) = indices.get(entity) {
                         // We found the index! Now we can mutate the central data source.
                         // `colors.0.write()` gets a write lock on the `MutableVec`.
-                        colors.0.write().remove(index);
-                        // IMPORTANT: After mutating a `MutableVec`, you must call `flush()`
-                        // to broadcast the changes to all listening signals.
-                        // We queue the flush command to be run at the end of the frame.
-                        commands.queue(colors.0.flush());
+                        colors.0.write(&mut mutable_vec_datas).remove(index);
                     }
                 },
             );
diff --git a/examples/test.rs b/examples/test.rs
index f13bd15..7e6bfe3 100644
--- a/examples/test.rs
+++ b/examples/test.rs
@@ -8,14 +8,14 @@ use jonmo::prelude::*;
 
 fn main() {
     let mut app = App::new();
-    let numbers = MutableVec::from([1, 2, 3, 4, 5]);
+    let numbers = MutableVecBuilder::from([1, 2, 3, 4, 5]).spawn(app.world_mut());
     app.add_plugins(examples_plugin)
         .insert_resource(Numbers(numbers.clone()))
         .add_systems(
             PostStartup,
             (
                 move |world: &mut World| {
-                    ui_root(numbers.clone()).spawn(world);
+                    ui_root(numbers.clone(), world).spawn(world);
                 },
                 camera,
             ),
@@ -32,10 +32,10 @@ struct Numbers(MutableVec<i32>);
 struct Lifetime(f32);
 
 #[rustfmt::skip]
-fn ui_root(numbers: MutableVec<i32>) -> JonmoBuilder {
-    let list_a = MutableVec::from([1, 2, 3, 4, 5]).signal_vec();
-    let list_b = MutableVec::from([3, 4, 5]).signal_vec();
-    let map = MutableBTreeMap::from([(1, 2), (2, 3)]);
+fn ui_root(numbers: MutableVec<i32>, world: &mut World) -> JonmoBuilder {
+    let list_a = MutableVecBuilder::from([1, 2, 3, 4, 5]).spawn(world).signal_vec();
+    let list_b = MutableVecBuilder::from([3, 4, 5]).spawn(world).signal_vec();
+    let map = MutableBTreeMapBuilder::from([(1, 2), (2, 3)]).spawn(world);
     // map.signal_map().
     JonmoBuilder::from(Node {
         height: Val::Percent(100.0),
@@ -136,18 +136,16 @@ fn live(mut lifetimes: Query<&mut Lifetime>, time: Res<Time>) {
     }
 }
 
-fn hotkeys(keys: Res<ButtonInput<KeyCode>>, numbers: ResMut<Numbers>, mut commands: Commands) {
-    let mut flush = false;
-    let mut guard = numbers.0.write();
+fn hotkeys(
+    keys: Res<ButtonInput<KeyCode>>,
+    numbers: ResMut<Numbers>,
+    mut mutable_vec_datas: Query<&mut MutableVecData<i32>>,
+) {
+    let mut guard = numbers.0.write(&mut mutable_vec_datas);
     if keys.just_pressed(KeyCode::Equal) {
         guard.push((guard.len() + 1) as i32);
-        flush = true;
     } else if keys.just_pressed(KeyCode::Minus) {
         guard.pop();
-        flush = true;
-    }
-    if flush {
-        commands.queue(numbers.0.flush());
     }
 }
 
diff --git a/repo_prompt.ncl b/repo_prompt.ncl
index b5759b8..f4f703c 100644
--- a/repo_prompt.ncl
+++ b/repo_prompt.ncl
@@ -11,6 +11,7 @@ let examples_basic = import "examples/basic.rs" as 'Text in
 let examples_lifetimes = import "examples/lifetimes.rs" as 'Text in
 let examples_filters = import "examples/filters.rs" as 'Text in
 let examples_counter = import "examples/counter.rs" as 'Text in
+let examples_letters = import "examples/letters.rs" as 'Text in
 let examples_test = import "examples/test.rs" as 'Text in
 let examples_utils = import "examples/utils.rs" as 'Text in
 let repo_structure = {
@@ -26,6 +27,7 @@ let repo_structure = {
   "examples/lifetimes.rs" = examples_lifetimes,
   "examples/filters.rs" = examples_filters,
   "examples/counter.rs" = examples_counter,
+  "examples/letters.rs" = examples_letters,
   "examples/test.rs" = examples_test,
   "examples/utils.rs" = examples_utils,
 } in
@@ -43,6 +45,7 @@ jonmo is a functional reactive signals implementation in rust for the bevy game
 │   ├── counter.rs
 │   ├── lifetimes.rs
 │   ├── filters.rs
+│   ├── letters.rs
 │   ├── test.rs
 │   └── utils.rs
 └── src/
diff --git a/rustfmt.toml b/rustfmt.toml
index 3bfb699..c99cdb9 100644
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -1,6 +1,7 @@
 edition = "2024"
 
 max_width = 120
+format_code_in_doc_comments = true
 # from bevy
 use_field_init_shorthand = true
 newline_style = "Unix"
diff --git a/src/builder.rs b/src/builder.rs
index 2ea6338..348512c 100644
--- a/src/builder.rs
+++ b/src/builder.rs
@@ -5,7 +5,11 @@ use super::{
     signal_vec::{SignalVec, SignalVecExt, VecDiff},
     utils::{LazyEntity, SSs, ancestor_map},
 };
-use bevy_ecs::{component::Mutable, prelude::*};
+use bevy_ecs::{
+    component::Mutable,
+    prelude::*,
+    system::{IntoObserverSystem, RunSystemOnce},
+};
 use bevy_platform::{
     prelude::*,
     sync::{Arc, Mutex},
@@ -60,6 +64,20 @@ impl JonmoBuilder {
         self
     }
 
+    /// Run a [`System`] which takes [`In`] this builder's [`Entity`].
+    pub fn on_spawn_with_system<T, M>(self, system: T) -> Self
+    where
+        T: IntoSystem<In<Entity>, (), M> + SSs,
+    {
+        self.on_spawn(|world, entity| {
+            #[allow(unused_variables)]
+            if let Err(error) = world.run_system_once_with(system, entity) {
+                #[cfg(feature = "tracing")]
+                bevy_log::error!("failed to run system on spawn: {}", error);
+            }
+        })
+    }
+
     /// Run a function with this builder's [`EntityWorldMut`].
     pub fn with_entity(self, f: impl FnOnce(EntityWorldMut) + SSs) -> Self {
         self.on_spawn(move |world, entity| {
@@ -86,6 +104,15 @@ impl JonmoBuilder {
         })
     }
 
+    /// Attach an [`Observer`] to this builder.
+    pub fn observe<E: Event, B: Bundle, Marker>(self, observer: impl IntoObserverSystem<E, B, Marker> + Sync) -> Self {
+        self.on_spawn(|world, entity| {
+            if let Ok(mut entity) = world.get_entity_mut(entity) {
+                entity.observe(observer);
+            }
+        })
+    }
+
     /// Set the [`LazyEntity`] to this builder's [`Entity`].
     pub fn entity_sync(self, entity: LazyEntity) -> Self {
         self.on_spawn(move |_, e| entity.set(e))
@@ -109,6 +136,23 @@ impl JonmoBuilder {
         self.on_spawn(on_spawn)
     }
 
+    /// Reactively run a function with this builder's [`EntityWorldMut`] and the output of a
+    /// [`Signal`].
+    ///
+    /// The `signal` will be automatically cleaned up when the [`Entity`] is despawned.
+    pub fn on_signal_with_entity<I, S, F>(self, signal: S, mut f: F) -> Self
+    where
+        I: Clone + 'static,
+        S: Signal<Item = I> + SSs,
+        F: FnMut(EntityWorldMut, I) + SSs,
+    {
+        self.on_signal(signal, move |In((entity, value)), world: &mut World| {
+            if let Ok(entity) = world.get_entity_mut(entity) {
+                f(entity, value)
+            }
+        })
+    }
+
     /// Reactively run a function with mutable access (via [`Mut`]) to this builder's [`Entity`]'s
     /// `C` [`Component`] if it exists and the output of a [`Signal`].
     ///
@@ -638,8 +682,9 @@ mod tests {
     use super::*;
     use crate::{
         JonmoPlugin,
-        prelude::MutableVec,
+        graph::STALE_SIGNALS,
         signal::{SignalBuilder, SignalExt},
+        signal_vec::MutableVecBuilder,
     };
     use bevy::prelude::*;
     use bevy_platform::collections::HashSet;
@@ -651,6 +696,11 @@ mod tests {
         app
     }
 
+    fn cleanup() {
+        STALE_SIGNALS.lock().unwrap().clear();
+        crate::signal_vec::tests::cleanup(true);
+    }
+
     #[test]
     fn test_on_signal() {
         // --- 1. Setup ---
@@ -902,8 +952,7 @@ mod tests {
             // The user takes the entity signal...
             entity_signal
                 // ...maps it to get a component from that entity...
-                .map(|In(entity): In<Entity>, query: Query<&TestComponent>| query.get(entity).ok().cloned())
-                // ...extracts the inner string...
+                .map(|In(entity): In<Entity>, query: Query<&TestComponent>| query.get(entity).ok().cloned()) // ...extracts the inner string...
                 .map_in(|component: TestComponent| component.0)
                 // ...and finally pipes it to our capturing system.
                 .map(capturing_system)
@@ -1329,110 +1378,115 @@ mod tests {
 
     #[test]
     fn test_signal_from_parent() {
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-
-        // A resource to capture the final output of the signal chains.
-        #[derive(Resource, Default, Clone)]
-        struct TestOutput(Arc<Mutex<Vec<String>>>);
-        app.init_resource::<TestOutput>();
-
-        // The component that the signal chain will read from the parent.
-        #[derive(Component, Clone, Debug, PartialEq)]
-        struct TestComponent(String);
-
-        // A system to capture the final output of the signal chain.
-        fn capturing_system(In(value): In<String>, output: Res<TestOutput>) {
-            output.0.lock().unwrap().push(value);
-        }
+        {
+            // --- 1. Setup ---
+            let mut app = create_test_app();
 
-        // The factory closure that will be passed to `signal_from_parent`.
-        // This represents the user's logic. It gets a signal for the parent entity,
-        // reads its TestComponent, extracts the string, and sends it to be captured.
-        let signal_chain_factory = |parent_entity_signal: crate::signal::Map<crate::signal::Source<Entity>, Entity>| {
-            parent_entity_signal
-                // Map the parent entity to its component. This will terminate if the
-                // parent doesn't have the component.
-                .map(|In(entity): In<Entity>, query: Query<&TestComponent>| query.get(entity).ok().cloned())
-                .map_in(|component: TestComponent| component.0) // Extract the string
-                .dedupe() // Add dedupe for robust reactivity testing
-                .map(capturing_system)
-        };
+            // A resource to capture the final output of the signal chains.
+            #[derive(Resource, Default, Clone)]
+            struct TestOutput(Arc<Mutex<Vec<String>>>);
+            app.init_resource::<TestOutput>();
 
-        // --- 2. Test Case: Basic Functionality & Reactivity ---
-        let parent = app.world_mut().spawn(TestComponent("Parent A".to_string())).id();
-        let child = app.world_mut().spawn_empty().id();
-        app.world_mut().entity_mut(parent).add_child(child);
+            // The component that the signal chain will read from the parent.
+            #[derive(Component, Clone, Debug, PartialEq)]
+            struct TestComponent(String);
 
-        let builder_with_parent = JonmoBuilder::new().signal_from_parent(signal_chain_factory);
-        builder_with_parent.spawn_on_entity(app.world_mut(), child);
+            // A system to capture the final output of the signal chain.
+            fn capturing_system(In(value): In<String>, output: Res<TestOutput>) {
+                output.0.lock().unwrap().push(value);
+            }
 
-        // Initial run
-        app.update();
-        let mut output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-        assert_eq!(output_guard.len(), 1, "Signal should run on initialization.");
-        assert_eq!(output_guard[0], "Parent A");
-        output_guard.clear();
-        drop(output_guard);
+            // The factory closure that will be passed to `signal_from_parent`.
+            // This represents the user's logic. It gets a signal for the parent entity,
+            // reads its TestComponent, extracts the string, and sends it to be captured.
+            let signal_chain_factory =
+                |parent_entity_signal: crate::signal::Map<crate::signal::Source<Entity>, Entity>| {
+                    parent_entity_signal
+                        // Map the parent entity to its component. This will terminate if the
+                        // parent doesn't have the component.
+                        .map(|In(entity): In<Entity>, query: Query<&TestComponent>| query.get(entity).ok().cloned())
+                        .map_in(|component: TestComponent| component.0) // Extract the string
+                        .dedupe() // Add dedupe for robust reactivity testing
+                        .map(capturing_system)
+                };
 
-        // Reactivity test
-        app.world_mut().get_mut::<TestComponent>(parent).unwrap().0 = "Parent B".to_string();
-        app.update();
-        let mut output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-        assert_eq!(
-            output_guard.len(),
-            1,
-            "Signal should re-run on parent component change."
-        );
-        assert_eq!(output_guard[0], "Parent B");
-        output_guard.clear();
-        drop(output_guard);
+            // --- 2. Test Case: Basic Functionality & Reactivity ---
+            let parent = app.world_mut().spawn(TestComponent("Parent A".to_string())).id();
+            let child = app.world_mut().spawn_empty().id();
+            app.world_mut().entity_mut(parent).add_child(child);
 
-        // --- 3. Test Case: No Parent ---
-        // A top-level entity with this signal should not run the chain.
-        let _top_level_entity = JonmoBuilder::new()
-            .signal_from_parent(signal_chain_factory)
-            .spawn(app.world_mut());
-        app.update();
-        let output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-        assert!(
-            output_guard.is_empty(),
-            "Signal should not run for an entity with no parent."
-        );
-        drop(output_guard);
+            let builder_with_parent = JonmoBuilder::new().signal_from_parent(signal_chain_factory);
+            builder_with_parent.spawn_on_entity(app.world_mut(), child);
 
-        // --- 4. Test Case: Parent Without Component ---
-        // The signal chain should terminate gracefully if the parent is missing the component.
-        let parent_no_comp = app.world_mut().spawn_empty().id();
-        let child_of_plain_parent = app.world_mut().spawn_empty().id();
-        app.world_mut()
-            .entity_mut(parent_no_comp)
-            .add_child(child_of_plain_parent);
+            // Initial run
+            app.update();
+            let mut output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
+            assert_eq!(output_guard.len(), 1, "Signal should run on initialization.");
+            assert_eq!(output_guard[0], "Parent A");
+            output_guard.clear();
+            drop(output_guard);
+
+            // Reactivity test
+            app.world_mut().get_mut::<TestComponent>(parent).unwrap().0 = "Parent B".to_string();
+            app.update();
+            let mut output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
+            assert_eq!(
+                output_guard.len(),
+                1,
+                "Signal should re-run on parent component change."
+            );
+            assert_eq!(output_guard[0], "Parent B");
+            output_guard.clear();
+            drop(output_guard);
+
+            // --- 3. Test Case: No Parent ---
+            // A top-level entity with this signal should not run the chain.
+            let _top_level_entity = JonmoBuilder::new()
+                .signal_from_parent(signal_chain_factory)
+                .spawn(app.world_mut());
+            app.update();
+            let output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
+            assert!(
+                output_guard.is_empty(),
+                "Signal should not run for an entity with no parent."
+            );
+            drop(output_guard);
+
+            // --- 4. Test Case: Parent Without Component ---
+            // The signal chain should terminate gracefully if the parent is missing the component.
+            let parent_no_comp = app.world_mut().spawn_empty().id();
+            let child_of_plain_parent = app.world_mut().spawn_empty().id();
+            app.world_mut()
+                .entity_mut(parent_no_comp)
+                .add_child(child_of_plain_parent);
+
+            let builder_plain_parent = JonmoBuilder::new().signal_from_parent(signal_chain_factory);
+            builder_plain_parent.spawn_on_entity(app.world_mut(), child_of_plain_parent);
+            app.update();
+            let output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
+            assert!(
+                output_guard.is_empty(),
+                "Signal should not run if parent is missing the target component."
+            );
+            drop(output_guard);
 
-        let builder_plain_parent = JonmoBuilder::new().signal_from_parent(signal_chain_factory);
-        builder_plain_parent.spawn_on_entity(app.world_mut(), child_of_plain_parent);
-        app.update();
-        let output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-        assert!(
-            output_guard.is_empty(),
-            "Signal should not run if parent is missing the target component."
-        );
-        drop(output_guard);
+            // --- 5. Test Case: Automatic Cleanup ---
+            // Despawn the child entity that holds the signal.
+            app.world_mut().entity_mut(child).despawn();
+            app.update(); // Process despawn commands.
 
-        // --- 5. Test Case: Automatic Cleanup ---
-        // Despawn the child entity that holds the signal.
-        app.world_mut().entity_mut(child).despawn();
-        app.update(); // Process despawn commands.
+            // Modify the parent's component again. The signal should no longer be active.
+            app.world_mut().get_mut::<TestComponent>(parent).unwrap().0 = "Parent C".to_string();
+            app.update();
 
-        // Modify the parent's component again. The signal should no longer be active.
-        app.world_mut().get_mut::<TestComponent>(parent).unwrap().0 = "Parent C".to_string();
-        app.update();
+            let output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
+            assert!(
+                output_guard.is_empty(),
+                "Signal should not run after its entity is despawned."
+            );
+        }
 
-        let output_guard = app.world().resource::<TestOutput>().0.lock().unwrap();
-        assert!(
-            output_guard.is_empty(),
-            "Signal should not run after its entity is despawned."
-        );
+        STALE_SIGNALS.lock().unwrap().clear();
     }
 
     #[test]
@@ -1866,7 +1920,7 @@ mod tests {
                 .map(|In(entity): In<Entity>, query: Query<&SourceComponent>| query.get(entity).ok().cloned())
                 // Map the `Option<SourceComponent>` to `Option<TargetComponent>`.
                 .map_in(|opt_source: Option<SourceComponent>| opt_source.map(|source| TargetComponent(source.0)))
-                // Dedupe to avoid unnecessary updates if the source value doesn't change.
+                // Dedupe to avoid    unnecessary updates if the source value doesn't change.
                 .dedupe()
         };
 
@@ -1989,8 +2043,7 @@ mod tests {
         let signal_factory = |parent_signal: crate::signal::Map<crate::signal::Source<Entity>, Entity>| {
             parent_signal
                 // Map the parent entity to its `SourceComponent`.
-                .map(|In(entity): In<Entity>, query: Query<&SourceComponent>| query.get(entity).ok().cloned())
-                // Map the `Option<SourceComponent>` to `Option<TargetComponent>`.
+                .map(|In(entity): In<Entity>, query: Query<&SourceComponent>| query.get(entity).ok().cloned()) // Map the `Option<SourceComponent>` to `Option<TargetComponent>`.
                 .map_in(|opt_source: Option<SourceComponent>| opt_source.map(|source| TargetComponent(source.0)))
                 .dedupe()
         };
@@ -2219,7 +2272,8 @@ mod tests {
         let entity_with_comp = builder_with_comp.spawn(app.world_mut());
         app.update();
 
-        // The factory should have received `Some(SourceComponent)` and produced the corresponding target.
+        // The factory should have received `Some(SourceComponent)` and produced the corresponding
+        // target.
         assert_eq!(
             app.world().get::<TargetComponent>(entity_with_comp),
             Some(&TargetComponent("Source: Data A".to_string())),
@@ -2288,204 +2342,208 @@ mod tests {
 
     #[test]
     fn test_child() {
-        // --- 1. Setup ---
-        let mut app = create_test_app();
+        {
+            // --- 1. Setup ---
+            let mut app = create_test_app();
+
+            // Marker components for identifying entities
+            #[derive(Component, Debug, PartialEq)]
+            struct ParentComp;
+            #[derive(Component, Debug, PartialEq)]
+            struct ChildCompA;
+            #[derive(Component, Debug, PartialEq)]
+            struct ChildCompB;
+            #[derive(Component, Debug, PartialEq)]
+            struct ChildCompC;
+            #[derive(Component, Debug, PartialEq)]
+            struct ChildCompD;
+            #[derive(Component, Debug, PartialEq)]
+            struct ChildCompE;
+
+            // Components for testing signal interaction
+            #[derive(Component, Clone, Debug, PartialEq)]
+            struct SourceComp(i32);
+            #[derive(Component, Clone, Debug, PartialEq)]
+            struct TargetComp(i32);
+
+            // --- 2. Test: Simple Parent-Child Relationship ---
+            let child_builder_simple = JonmoBuilder::new().insert((ChildCompA, Name::new("SimpleChild")));
+            let parent_builder_simple = JonmoBuilder::new().insert(ParentComp).child(child_builder_simple);
+
+            let parent_entity_simple = parent_builder_simple.spawn(app.world_mut());
+            app.update();
 
-        // Marker components for identifying entities
-        #[derive(Component, Debug, PartialEq)]
-        struct ParentComp;
-        #[derive(Component, Debug, PartialEq)]
-        struct ChildCompA;
-        #[derive(Component, Debug, PartialEq)]
-        struct ChildCompB;
-        #[derive(Component, Debug, PartialEq)]
-        struct ChildCompC;
-        #[derive(Component, Debug, PartialEq)]
-        struct ChildCompD;
-        #[derive(Component, Debug, PartialEq)]
-        struct ChildCompE;
-
-        // Components for testing signal interaction
-        #[derive(Component, Clone, Debug, PartialEq)]
-        struct SourceComp(i32);
-        #[derive(Component, Clone, Debug, PartialEq)]
-        struct TargetComp(i32);
+            let mut children_query = app.world_mut().query::<&Children>();
+            let parent_children = children_query.get(app.world(), parent_entity_simple).unwrap();
+            assert_eq!(parent_children.len(), 1, "Parent should have exactly one child.");
+            let child_entity_simple = parent_children[0];
 
-        // --- 2. Test: Simple Parent-Child Relationship ---
-        let child_builder_simple = JonmoBuilder::new().insert((ChildCompA, Name::new("SimpleChild")));
-        let parent_builder_simple = JonmoBuilder::new().insert(ParentComp).child(child_builder_simple);
+            // Verify child's components
+            let child_entity_ref = app.world().entity(child_entity_simple);
+            assert!(child_entity_ref.contains::<ChildCompA>());
+            assert_eq!(child_entity_ref.get::<Name>().unwrap().as_str(), "SimpleChild");
 
-        let parent_entity_simple = parent_builder_simple.spawn(app.world_mut());
-        app.update();
+            // Verify parent relationship from child's perspective
+            let mut parent_query = app.world_mut().query::<&bevy::prelude::ChildOf>();
+            let childs_parent = parent_query.get(app.world(), child_entity_simple).unwrap();
+            assert_eq!(childs_parent.parent(), parent_entity_simple);
 
-        let mut children_query = app.world_mut().query::<&Children>();
-        let parent_children = children_query.get(app.world(), parent_entity_simple).unwrap();
-        assert_eq!(parent_children.len(), 1, "Parent should have exactly one child.");
-        let child_entity_simple = parent_children[0];
+            // Cleanup for next test
+            app.world_mut().entity_mut(parent_entity_simple).despawn();
+            app.update();
 
-        // Verify child's components
-        let child_entity_ref = app.world().entity(child_entity_simple);
-        assert!(child_entity_ref.contains::<ChildCompA>());
-        assert_eq!(child_entity_ref.get::<Name>().unwrap().as_str(), "SimpleChild");
+            // --- 3. Test: Multiple Chained Children & Correct Order ---
+            let parent_builder_chained = JonmoBuilder::new()
+                .insert(ParentComp)
+                .child(JonmoBuilder::new().insert(ChildCompA))
+                .child(JonmoBuilder::new().insert(ChildCompB));
 
-        // Verify parent relationship from child's perspective
-        let mut parent_query = app.world_mut().query::<&bevy::prelude::ChildOf>();
-        let childs_parent = parent_query.get(app.world(), child_entity_simple).unwrap();
-        assert_eq!(childs_parent.parent(), parent_entity_simple);
+            let parent_entity_chained = parent_builder_chained.spawn(app.world_mut());
+            app.update();
 
-        // Cleanup for next test
-        app.world_mut().entity_mut(parent_entity_simple).despawn();
-        app.update();
+            let children = app.world().get::<Children>(parent_entity_chained).unwrap();
+            assert_eq!(children.len(), 2, "Parent should have two children.");
 
-        // --- 3. Test: Multiple Chained Children & Correct Order ---
-        let parent_builder_chained = JonmoBuilder::new()
-            .insert(ParentComp)
-            .child(JonmoBuilder::new().insert(ChildCompA))
-            .child(JonmoBuilder::new().insert(ChildCompB));
+            let child_a_entity = children[0];
+            let child_b_entity = children[1];
 
-        let parent_entity_chained = parent_builder_chained.spawn(app.world_mut());
-        app.update();
+            assert!(
+                app.world().entity(child_a_entity).contains::<ChildCompA>(),
+                "First child should be A"
+            );
+            assert!(
+                app.world().entity(child_b_entity).contains::<ChildCompB>(),
+                "Second child should be B"
+            );
 
-        let children = app.world().get::<Children>(parent_entity_chained).unwrap();
-        assert_eq!(children.len(), 2, "Parent should have two children.");
+            // Cleanup
+            app.world_mut().entity_mut(parent_entity_chained).despawn();
+            app.update();
 
-        let child_a_entity = children[0];
-        let child_b_entity = children[1];
+            // --- 4. Test: Nested Hierarchy ---
+            let grandchild_builder = JonmoBuilder::new().insert(Name::new("Grandchild"));
+            let child_builder_nested = JonmoBuilder::new().insert(Name::new("Child")).child(grandchild_builder);
+            let grandparent_builder = JonmoBuilder::new()
+                .insert(Name::new("Grandparent"))
+                .child(child_builder_nested);
 
-        assert!(
-            app.world().entity(child_a_entity).contains::<ChildCompA>(),
-            "First child should be A"
-        );
-        assert!(
-            app.world().entity(child_b_entity).contains::<ChildCompB>(),
-            "Second child should be B"
-        );
+            let grandparent_entity = grandparent_builder.spawn(app.world_mut());
+            app.update();
 
-        // Cleanup
-        app.world_mut().entity_mut(parent_entity_chained).despawn();
-        app.update();
+            let gp_children = app.world().get::<Children>(grandparent_entity).unwrap();
+            assert_eq!(gp_children.len(), 1);
+            let child_entity_nested = gp_children[0];
+            assert_eq!(app.world().get::<Name>(child_entity_nested).unwrap().as_str(), "Child");
 
-        // --- 4. Test: Nested Hierarchy ---
-        let grandchild_builder = JonmoBuilder::new().insert(Name::new("Grandchild"));
-        let child_builder_nested = JonmoBuilder::new().insert(Name::new("Child")).child(grandchild_builder);
-        let grandparent_builder = JonmoBuilder::new()
-            .insert(Name::new("Grandparent"))
-            .child(child_builder_nested);
+            let child_children = app.world().get::<Children>(child_entity_nested).unwrap();
+            assert_eq!(child_children.len(), 1);
+            let grandchild_entity = child_children[0];
+            assert_eq!(
+                app.world().get::<Name>(grandchild_entity).unwrap().as_str(),
+                "Grandchild"
+            );
 
-        let grandparent_entity = grandparent_builder.spawn(app.world_mut());
-        app.update();
+            // Cleanup
+            app.world_mut().entity_mut(grandparent_entity).despawn();
+            app.update();
 
-        let gp_children = app.world().get::<Children>(grandparent_entity).unwrap();
-        assert_eq!(gp_children.len(), 1);
-        let child_entity_nested = gp_children[0];
-        assert_eq!(app.world().get::<Name>(child_entity_nested).unwrap().as_str(), "Child");
+            // --- 5. Test: Mixed Child Types for Correct Ordering ---
+            #[derive(Resource, Default, Deref, DerefMut, Clone)]
+            struct SignalTrigger(bool);
+            app.init_resource::<SignalTrigger>();
 
-        let child_children = app.world().get::<Children>(child_entity_nested).unwrap();
-        assert_eq!(child_children.len(), 1);
-        let grandchild_entity = child_children[0];
-        assert_eq!(
-            app.world().get::<Name>(grandchild_entity).unwrap().as_str(),
-            "Grandchild"
-        );
-
-        // Cleanup
-        app.world_mut().entity_mut(grandparent_entity).despawn();
-        app.update();
-
-        // --- 5. Test: Mixed Child Types for Correct Ordering ---
-        #[derive(Resource, Default, Deref, DerefMut, Clone)]
-        struct SignalTrigger(bool);
-        app.init_resource::<SignalTrigger>();
-
-        let child_a = JonmoBuilder::new().insert(ChildCompA);
-        let child_b = JonmoBuilder::new().insert(ChildCompB);
-        let child_c = JonmoBuilder::new().insert(ChildCompC);
-        let child_d = JonmoBuilder::new().insert(ChildCompD);
-        let child_e = JonmoBuilder::new().insert(ChildCompE);
-
-        let parent_builder_mixed = JonmoBuilder::new()
-            .insert(ParentComp)
-            .child(child_a) // Block 0, offset 0
-            .children([child_b.clone(), child_c.clone()]) // Block 1, offset 1
-            .child(child_d) // Block 2, offset 3
-            .child_signal(
-                // Block 3, offset 4
-                SignalBuilder::from_resource::<SignalTrigger>().map_in::<Option<JonmoBuilder>, _, _>(
-                    move |trigger: SignalTrigger| if trigger.0 { Some(child_e.clone()) } else { None },
-                ),
-            );
+            let child_a = JonmoBuilder::new().insert(ChildCompA);
+            let child_b = JonmoBuilder::new().insert(ChildCompB);
+            let child_c = JonmoBuilder::new().insert(ChildCompC);
+            let child_d = JonmoBuilder::new().insert(ChildCompD);
+            let child_e = JonmoBuilder::new().insert(ChildCompE);
 
-        let parent_entity_mixed = parent_builder_mixed.spawn(app.world_mut());
+            let parent_builder_mixed = JonmoBuilder::new()
+                .insert(ParentComp)
+                .child(child_a) // Block 0, offset 0
+                .children([child_b.clone(), child_c.clone()]) // Block 1, offset 1
+                .child(child_d) // Block 2, offset 3
+                .child_signal(
+                    // Block 3, offset 4
+                    SignalBuilder::from_resource::<SignalTrigger>().map_in::<Option<JonmoBuilder>, _, _>(
+                        move |trigger: SignalTrigger| if trigger.0 { Some(child_e.clone()) } else { None },
+                    ),
+                );
 
-        // Initially, signal is false, so child E should not exist.
-        app.update();
-        let children_mixed = app.world().get::<Children>(parent_entity_mixed).unwrap();
-        assert_eq!(children_mixed.len(), 4, "Should have 4 children initially.");
-        assert!(app.world().entity(children_mixed[0]).contains::<ChildCompA>());
-        assert!(app.world().entity(children_mixed[1]).contains::<ChildCompB>());
-        assert!(app.world().entity(children_mixed[2]).contains::<ChildCompC>());
-        assert!(app.world().entity(children_mixed[3]).contains::<ChildCompD>());
+            let parent_entity_mixed = parent_builder_mixed.spawn(app.world_mut());
 
-        // Trigger the signal to add child E.
-        app.world_mut().resource_mut::<SignalTrigger>().0 = true;
-        app.update();
+            // Initially, signal is false, so child E should not exist.
+            app.update();
+            let children_mixed = app.world().get::<Children>(parent_entity_mixed).unwrap();
+            assert_eq!(children_mixed.len(), 4, "Should have 4 children initially.");
+            assert!(app.world().entity(children_mixed[0]).contains::<ChildCompA>());
+            assert!(app.world().entity(children_mixed[1]).contains::<ChildCompB>());
+            assert!(app.world().entity(children_mixed[2]).contains::<ChildCompC>());
+            assert!(app.world().entity(children_mixed[3]).contains::<ChildCompD>());
+
+            // Trigger the signal to add child E.
+            app.world_mut().resource_mut::<SignalTrigger>().0 = true;
+            app.update();
 
-        let children_mixed_after = app.world().get::<Children>(parent_entity_mixed).unwrap();
-        assert_eq!(
-            children_mixed_after.len(),
-            5,
-            "Should have 5 children after signal trigger."
-        );
-        // Verify the full order
-        assert!(app.world().entity(children_mixed_after[0]).contains::<ChildCompA>());
-        assert!(app.world().entity(children_mixed_after[1]).contains::<ChildCompB>());
-        assert!(app.world().entity(children_mixed_after[2]).contains::<ChildCompC>());
-        assert!(app.world().entity(children_mixed_after[3]).contains::<ChildCompD>());
-        assert!(
-            app.world().entity(children_mixed_after[4]).contains::<ChildCompE>(),
-            "Child E should be last."
-        );
+            let children_mixed_after = app.world().get::<Children>(parent_entity_mixed).unwrap();
+            assert_eq!(
+                children_mixed_after.len(),
+                5,
+                "Should have 5 children after signal trigger."
+            );
+            // Verify the full order
+            assert!(app.world().entity(children_mixed_after[0]).contains::<ChildCompA>());
+            assert!(app.world().entity(children_mixed_after[1]).contains::<ChildCompB>());
+            assert!(app.world().entity(children_mixed_after[2]).contains::<ChildCompC>());
+            assert!(app.world().entity(children_mixed_after[3]).contains::<ChildCompD>());
+            assert!(
+                app.world().entity(children_mixed_after[4]).contains::<ChildCompE>(),
+                "Child E should be last."
+            );
 
-        // Cleanup
-        app.world_mut().entity_mut(parent_entity_mixed).despawn();
-        app.update();
+            // Cleanup
+            app.world_mut().entity_mut(parent_entity_mixed).despawn();
+            app.update();
 
-        // --- 6. Test: Child's Signals Function Correctly ---
-        let child_builder_with_signal = JonmoBuilder::new().component_signal_from_parent(|parent_signal| {
-            parent_signal
-                .component::<SourceComp>()
-                .map_in(|source: SourceComp| Some(TargetComp(source.0 * 2)))
-        });
+            // --- 6. Test: Child's Signals Function Correctly ---
+            let child_builder_with_signal = JonmoBuilder::new().component_signal_from_parent(|parent_signal| {
+                parent_signal
+                    .component::<SourceComp>()
+                    .map_in(|source: SourceComp| Some(TargetComp(source.0 * 2)))
+            });
 
-        let parent_builder_with_signal = JonmoBuilder::new()
-            .insert(SourceComp(10))
-            .child(child_builder_with_signal);
+            let parent_builder_with_signal = JonmoBuilder::new()
+                .insert(SourceComp(10))
+                .child(child_builder_with_signal);
 
-        let parent_entity_signal = parent_builder_with_signal.spawn(app.world_mut());
-        app.update();
+            let parent_entity_signal = parent_builder_with_signal.spawn(app.world_mut());
+            app.update();
 
-        let child_entity_signal = app.world().get::<Children>(parent_entity_signal).unwrap()[0];
-        let child_target_comp = app.world().get::<TargetComp>(child_entity_signal);
+            let child_entity_signal = app.world().get::<Children>(parent_entity_signal).unwrap()[0];
+            let child_target_comp = app.world().get::<TargetComp>(child_entity_signal);
 
-        assert_eq!(
-            child_target_comp,
-            Some(&TargetComp(20)),
-            "Child's signal did not correctly read parent component and update itself."
-        );
+            assert_eq!(
+                child_target_comp,
+                Some(&TargetComp(20)),
+                "Child's signal did not correctly read parent component and update itself."
+            );
 
-        // Test reactivity: change parent component, check child.
-        app.world_mut().get_mut::<SourceComp>(parent_entity_signal).unwrap().0 = 50;
-        app.update();
-        let child_target_comp_updated = app.world().get::<TargetComp>(child_entity_signal);
-        assert_eq!(
-            child_target_comp_updated,
-            Some(&TargetComp(100)),
-            "Child's signal did not react to parent component change."
-        );
+            // Test reactivity: change parent component, check child.
+            app.world_mut().get_mut::<SourceComp>(parent_entity_signal).unwrap().0 = 50;
+            app.update();
+            let child_target_comp_updated = app.world().get::<TargetComp>(child_entity_signal);
+            assert_eq!(
+                child_target_comp_updated,
+                Some(&TargetComp(100)),
+                "Child's signal did not react to parent component change."
+            );
 
-        // Cleanup
-        app.world_mut().entity_mut(parent_entity_signal).despawn();
-        app.update();
+            // Cleanup
+            app.world_mut().entity_mut(parent_entity_signal).despawn();
+            app.update();
+        }
+
+        cleanup()
     }
 
     // Marker components for easy identification in the child_signal test
@@ -2528,383 +2586,391 @@ mod tests {
 
     #[test]
     fn test_child_signal() {
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-        app.init_resource::<SignalSource>();
-
-        // A factory function to create reactive child builders based on a number
-        let reactive_child_factory = |id: u32| JonmoBuilder::new().insert(ReactiveChild(id));
-
-        // The signal that maps the resource to an Option<JonmoBuilder>
-        let source_signal = SignalBuilder::from_resource::<SignalSource>()
-            .dedupe()
-            .map_in(move |source: SignalSource| source.0.map(reactive_child_factory));
-
-        // --- 2. Build the Parent Entity ---
-        // This builder has static children sandwiching the reactive one to test ordering.
-        let parent_builder = JonmoBuilder::new()
-            .insert(ParentComp)
-            .child(JonmoBuilder::new().insert(StaticChildBefore)) // Child in block 0
-            .child_signal(source_signal) // Child in block 1
-            .child(JonmoBuilder::new().insert(StaticChildAfter)); // Child in block 2
-
-        let parent_entity = parent_builder.spawn(app.world_mut());
-
-        // --- 3. Run Test Cases ---
-
-        // Case A: Initial state (Source is None).
-        // Should only have the static children.
-        app.update();
-        assert_eq!(
-            get_child_types(app.world_mut(), parent_entity),
-            vec!["Before", "After"],
-            "Initial state with None should only have static children"
-        );
-        assert_eq!(app.world().get::<Children>(parent_entity).unwrap().len(), 2);
-
-        // Case B: Transition None -> Some(1)
-        app.world_mut().resource_mut::<SignalSource>().0 = Some(1);
-        app.update();
-        assert_eq!(
-            get_child_types(app.world_mut(), parent_entity),
-            vec!["Before", "Reactive(1)", "After"],
-            "Transition None->Some failed to create and order child correctly"
-        );
-        assert_eq!(app.world().get::<Children>(parent_entity).unwrap().len(), 3);
-
-        // Case C: No change (still Some(1)).
-        // Because of .dedupe(), the signal doesn't fire, nothing should change.
-        app.update();
-        assert_eq!(
-            get_child_types(app.world_mut(), parent_entity),
-            vec!["Before", "Reactive(1)", "After"],
-            "No-op update should not change children"
-        );
-        assert_eq!(app.world().get::<Children>(parent_entity).unwrap().len(), 3);
-
-        // Case D: Transition Some(1) -> Some(2)
-        // The old child should be despawned, and the new one spawned in its place.
-        let old_child_entity = app.world().get::<Children>(parent_entity).unwrap()[1];
-        app.world_mut().resource_mut::<SignalSource>().0 = Some(2);
-        app.update();
-        assert_eq!(
-            get_child_types(app.world_mut(), parent_entity),
-            vec!["Before", "Reactive(2)", "After"],
-            "Transition Some->Some failed to replace and order child correctly"
-        );
-        assert_eq!(app.world().get::<Children>(parent_entity).unwrap().len(), 3);
-        assert!(
-            app.world().get_entity(old_child_entity).is_err(),
-            "Old reactive child was not despawned on replacement"
-        );
-
-        // Case E: Transition Some(2) -> None
-        let old_child_entity = app.world().get::<Children>(parent_entity).unwrap()[1];
-        app.world_mut().resource_mut::<SignalSource>().0 = None;
-        app.update();
-        assert_eq!(
-            get_child_types(app.world_mut(), parent_entity),
-            vec!["Before", "After"],
-            "Transition Some->None failed to remove child"
-        );
-        assert_eq!(app.world().get::<Children>(parent_entity).unwrap().len(), 2);
-        assert!(
-            app.world().get_entity(old_child_entity).is_err(),
-            "Reactive child was not despawned on transition to None"
-        );
-
-        // Case F: Transition back to Some(3)
-        app.world_mut().resource_mut::<SignalSource>().0 = Some(3);
-        app.update();
-        assert_eq!(
-            get_child_types(app.world_mut(), parent_entity),
-            vec!["Before", "Reactive(3)", "After"],
-            "Transition back to Some failed"
-        );
-        assert_eq!(app.world().get::<Children>(parent_entity).unwrap().len(), 3);
-
-        // --- 4. Test Cleanup ---
-        let child_to_despawn = app.world().get::<Children>(parent_entity).unwrap()[1];
-        app.world_mut().entity_mut(parent_entity).despawn();
-        app.update(); // Process despawn command.
-
-        assert!(
-            app.world().get_entity(parent_entity).is_err(),
-            "Parent should be despawned."
-        );
-        assert!(
-            app.world().get_entity(child_to_despawn).is_err(),
-            "Reactive child should be despawned with parent."
-        );
-
-        // Trigger the signal again. This should not panic or create any entities,
-        // as the signal system tied to the parent should have been cleaned up.
-        app.world_mut().resource_mut::<SignalSource>().0 = Some(4);
-        app.update();
-
-        let mut reactive_children_query = app.world_mut().query::<&ReactiveChild>();
-        assert_eq!(
-            reactive_children_query.iter(app.world()).count(),
-            0,
-            "No reactive children should exist after parent is despawned."
-        );
-    }
+        {
+            // --- 1. Setup ---
+            let mut app = create_test_app();
+            app.init_resource::<SignalSource>();
 
-    #[test]
-    fn test_children() {
-        // --- 1. SETUP ---
-        // This comprehensive test validates multiple aspects of the `children` method.
-        let mut app = create_test_app();
+            // A factory function to create reactive child builders based on a number
+            let reactive_child_factory = |id: u32| JonmoBuilder::new().insert(ReactiveChild(id));
 
-        // Marker components for identifying entities in assertions.
-        #[derive(Component, Debug, PartialEq)]
-        struct ParentComp;
-        #[derive(Component, Debug, PartialEq)]
-        struct ChildCompA;
-        #[derive(Component, Debug, PartialEq)]
-        struct ChildCompB;
-        #[derive(Component, Debug, PartialEq)]
-        struct ChildCompC;
-        #[derive(Component, Debug, PartialEq)]
-        struct ChildCompD;
-        #[derive(Component, Debug, PartialEq)]
-        struct ChildCompE;
-        #[derive(Component, Debug, PartialEq)]
-        struct ChildCompF;
-        #[derive(Component, Debug, PartialEq)]
-        struct ChildCompG;
-        #[derive(Component, Debug, PartialEq)]
-        struct ChildCompH;
-        #[derive(Component, Debug, PartialEq)]
-        struct GrandchildComp;
-
-        // Components for testing signal interaction within children.
-        #[derive(Component, Clone, Debug, PartialEq)]
-        struct SourceComp(i32);
-        #[derive(Component, Clone, Debug, PartialEq)]
-        struct TargetComp(i32);
+            // The signal that maps the resource to an Option<JonmoBuilder>
+            let source_signal = SignalBuilder::from_resource::<SignalSource>()
+                .dedupe()
+                .map_in(move |source: SignalSource| source.0.map(reactive_child_factory));
 
-        // --- 2. TEST CASE: Basic Functionality & Correct Order ---
-        // Verifies that a simple list of builders is spawned correctly as children and in the
-        // specified order.
-        {
-            let child_builders = vec![
-                JonmoBuilder::new().insert(ChildCompA),
-                JonmoBuilder::new().insert(ChildCompB),
-                JonmoBuilder::new().insert(ChildCompC),
-            ];
-            let parent_builder = JonmoBuilder::new().insert(ParentComp).children(child_builders);
+            // --- 2. Build the Parent Entity ---
+            // This builder has static children sandwiching the reactive one to test ordering.
+            let parent_builder = JonmoBuilder::new()
+                .insert(ParentComp)
+                .child(JonmoBuilder::new().insert(StaticChildBefore)) // Child in block 0
+                .child_signal(source_signal) // Child in block 1
+                .child(JonmoBuilder::new().insert(StaticChildAfter)); // Child in block 2
 
             let parent_entity = parent_builder.spawn(app.world_mut());
-            app.update();
 
-            let children = app
-                .world()
-                .get::<Children>(parent_entity)
-                .expect("Parent should have Children component.")
-                .iter()
-                .collect::<Vec<_>>();
-            assert_eq!(children.len(), 3, "Parent should have exactly 3 children.");
+            // --- 3. Run Test Cases ---
 
-            // Verify order and components
-            assert!(
-                app.world().entity(children[0]).contains::<ChildCompA>(),
-                "Child 0 should be A"
-            );
-            assert!(
-                app.world().entity(children[1]).contains::<ChildCompB>(),
-                "Child 1 should be B"
-            );
-            assert!(
-                app.world().entity(children[2]).contains::<ChildCompC>(),
-                "Child 2 should be C"
+            // Case A: Initial state (Source is None).
+            // Should only have the static children.
+            app.update();
+            assert_eq!(
+                get_child_types(app.world_mut(), parent_entity),
+                vec!["Before", "After"],
+                "Initial state with None should only have static children"
             );
+            assert_eq!(app.world().get::<Children>(parent_entity).unwrap().len(), 2);
 
-            // Verify parent relationship from each child's perspective
-            let mut parent_rel_query = app.world_mut().query::<&bevy::prelude::ChildOf>();
-            for child_entity in children.into_iter() {
-                assert_eq!(
-                    parent_rel_query.get(app.world(), child_entity).unwrap().parent(),
-                    parent_entity
-                );
-            }
-
-            app.world_mut().entity_mut(parent_entity).despawn();
+            // Case B: Transition None -> Some(1)
+            app.world_mut().resource_mut::<SignalSource>().0 = Some(1);
             app.update();
-        }
+            assert_eq!(
+                get_child_types(app.world_mut(), parent_entity),
+                vec!["Before", "Reactive(1)", "After"],
+                "Transition None->Some failed to create and order child correctly"
+            );
+            assert_eq!(app.world().get::<Children>(parent_entity).unwrap().len(), 3);
 
-        // --- 3. TEST CASE: Empty Iterator ---
-        // Verifies that providing an empty iterator results in no children being added.
-        {
-            // The type hint is needed for an empty vec.
-            let parent_builder_empty = JonmoBuilder::new()
-                .insert(ParentComp)
-                .children(vec![] as Vec<JonmoBuilder>);
-            let parent_entity_empty = parent_builder_empty.spawn(app.world_mut());
+            // Case C: No change (still Some(1)).
+            // Because of .dedupe(), the signal doesn't fire, nothing should change.
             app.update();
-            assert!(
-                app.world().get::<Children>(parent_entity_empty).is_none(),
-                "Parent with empty children iterator should not have a Children component."
+            assert_eq!(
+                get_child_types(app.world_mut(), parent_entity),
+                vec!["Before", "Reactive(1)", "After"],
+                "No-op update should not change children"
             );
+            assert_eq!(app.world().get::<Children>(parent_entity).unwrap().len(), 3);
 
-            app.world_mut().entity_mut(parent_entity_empty).despawn();
+            // Case D: Transition Some(1) -> Some(2)
+            // The old child should be despawned, and the new one spawned in its place.
+            let old_child_entity = app.world().get::<Children>(parent_entity).unwrap()[1];
+            app.world_mut().resource_mut::<SignalSource>().0 = Some(2);
             app.update();
-        }
+            assert_eq!(
+                get_child_types(app.world_mut(), parent_entity),
+                vec!["Before", "Reactive(2)", "After"],
+                "Transition Some->Some failed to replace and order child correctly"
+            );
+            assert_eq!(app.world().get::<Children>(parent_entity).unwrap().len(), 3);
+            assert!(
+                app.world().get_entity(old_child_entity).is_err(),
+                "Old reactive child was not despawned on replacement"
+            );
 
-        // --- 4. TEST CASE: Complex Children and Cleanup ---
-        // Verifies that children can have their own complex logic (signals, hierarchy) and that
-        // they are properly cleaned up when the parent is despawned.
-        {
-            let complex_child_builder = JonmoBuilder::new()
-                .insert(ChildCompD)
-                .child(JonmoBuilder::new().insert(GrandchildComp)) // Nested child
-                .component_signal_from_parent(|parent_signal| {
-                    // Signal reading from parent
-                    parent_signal
-                        .component::<SourceComp>()
-                        .map_in(|source: SourceComp| Some(TargetComp(source.0 * 10)))
-                });
-
-            let parent_builder_complex = JonmoBuilder::new()
-                .insert((ParentComp, SourceComp(5)))
-                .children(vec![complex_child_builder]);
-
-            let parent_entity_complex = parent_builder_complex.spawn(app.world_mut());
+            // Case E: Transition Some(2) -> None
+            let old_child_entity = app.world().get::<Children>(parent_entity).unwrap()[1];
+            app.world_mut().resource_mut::<SignalSource>().0 = None;
             app.update();
-
-            let complex_children = app.world().get::<Children>(parent_entity_complex).unwrap();
-            let complex_child_entity = complex_children[0];
-
-            // Verify signal ran correctly
             assert_eq!(
-                app.world().get::<TargetComp>(complex_child_entity),
-                Some(&TargetComp(50))
+                get_child_types(app.world_mut(), parent_entity),
+                vec!["Before", "After"],
+                "Transition Some->None failed to remove child"
+            );
+            assert_eq!(app.world().get::<Children>(parent_entity).unwrap().len(), 2);
+            assert!(
+                app.world().get_entity(old_child_entity).is_err(),
+                "Reactive child was not despawned on transition to None"
             );
 
-            // Verify nested hierarchy
-            let grandchild_entity = app.world().get::<Children>(complex_child_entity).unwrap()[0];
-            assert!(app.world().entity(grandchild_entity).contains::<GrandchildComp>());
-
-            // Test reactivity
-            app.world_mut().get_mut::<SourceComp>(parent_entity_complex).unwrap().0 = 7;
+            // Case F: Transition back to Some(3)
+            app.world_mut().resource_mut::<SignalSource>().0 = Some(3);
             app.update();
             assert_eq!(
-                app.world().get::<TargetComp>(complex_child_entity),
-                Some(&TargetComp(70)),
-                "Signal did not react to parent's component change."
+                get_child_types(app.world_mut(), parent_entity),
+                vec!["Before", "Reactive(3)", "After"],
+                "Transition back to Some failed"
             );
+            assert_eq!(app.world().get::<Children>(parent_entity).unwrap().len(), 3);
 
-            // Test cleanup
-            app.world_mut().entity_mut(parent_entity_complex).despawn();
-            app.update();
+            // --- 4. Test Cleanup ---
+            let child_to_despawn = app.world().get::<Children>(parent_entity).unwrap()[1];
+            app.world_mut().entity_mut(parent_entity).despawn();
+            app.update(); // Process despawn command.
 
             assert!(
-                app.world().get_entity(complex_child_entity).is_err(),
-                "Complex child should be despawned with parent."
+                app.world().get_entity(parent_entity).is_err(),
+                "Parent should be despawned."
             );
             assert!(
-                app.world().get_entity(grandchild_entity).is_err(),
-                "Grandchild should be despawned with parent."
+                app.world().get_entity(child_to_despawn).is_err(),
+                "Reactive child should be despawned with parent."
+            );
+
+            // Trigger the signal again. This should not panic or create any entities,
+            // as the signal system tied to the parent should have been cleaned up.
+            app.world_mut().resource_mut::<SignalSource>().0 = Some(4);
+            app.update();
+
+            let mut reactive_children_query = app.world_mut().query::<&ReactiveChild>();
+            assert_eq!(
+                reactive_children_query.iter(app.world()).count(),
+                0,
+                "No reactive children should exist after parent is despawned."
             );
         }
 
-        // --- 5. TEST CASE: Mixed Ordering with Other Child Methods ---
-        // This is a critical test to ensure the internal offset calculation is correct when
-        // `children` is mixed with `child`, `child_signal`, etc.
+        cleanup()
+    }
+
+    #[test]
+    fn test_children() {
         {
-            // Helper to verify the exact order of children by their components.
-            fn get_ordered_child_markers(world: &World, parent: Entity) -> Vec<&'static str> {
-                let Some(children) = world.get::<Children>(parent) else {
-                    return vec![];
-                };
-                children
+            // --- 1. SETUP ---
+            // This comprehensive test validates multiple aspects of the `children` method.
+            let mut app = create_test_app();
+
+            // Marker components for identifying entities in assertions.
+            #[derive(Component, Debug, PartialEq)]
+            struct ParentComp;
+            #[derive(Component, Debug, PartialEq)]
+            struct ChildCompA;
+            #[derive(Component, Debug, PartialEq)]
+            struct ChildCompB;
+            #[derive(Component, Debug, PartialEq)]
+            struct ChildCompC;
+            #[derive(Component, Debug, PartialEq)]
+            struct ChildCompD;
+            #[derive(Component, Debug, PartialEq)]
+            struct ChildCompE;
+            #[derive(Component, Debug, PartialEq)]
+            struct ChildCompF;
+            #[derive(Component, Debug, PartialEq)]
+            struct ChildCompG;
+            #[derive(Component, Debug, PartialEq)]
+            struct ChildCompH;
+            #[derive(Component, Debug, PartialEq)]
+            struct GrandchildComp;
+
+            // Components for testing signal interaction within children.
+            #[derive(Component, Clone, Debug, PartialEq)]
+            struct SourceComp(i32);
+            #[derive(Component, Clone, Debug, PartialEq)]
+            struct TargetComp(i32);
+
+            // --- 2. TEST CASE: Basic Functionality & Correct Order ---
+            // Verifies that a simple list of builders is spawned correctly as children and in the
+            // specified order.
+            {
+                let child_builders = vec![
+                    JonmoBuilder::new().insert(ChildCompA),
+                    JonmoBuilder::new().insert(ChildCompB),
+                    JonmoBuilder::new().insert(ChildCompC),
+                ];
+                let parent_builder = JonmoBuilder::new().insert(ParentComp).children(child_builders);
+
+                let parent_entity = parent_builder.spawn(app.world_mut());
+                app.update();
+
+                let children = app
+                    .world()
+                    .get::<Children>(parent_entity)
+                    .expect("Parent should have Children component.")
                     .iter()
-                    .map(|child_entity| {
-                        let e = world.entity(child_entity);
-                        if e.contains::<ChildCompA>() {
-                            "A"
-                        } else if e.contains::<ChildCompB>() {
-                            "B"
-                        } else if e.contains::<ChildCompC>() {
-                            "C"
-                        } else if e.contains::<ChildCompD>() {
-                            "D"
-                        } else if e.contains::<ChildCompE>() {
-                            "E"
-                        } else if e.contains::<ChildCompF>() {
-                            "F"
-                        } else if e.contains::<ChildCompG>() {
-                            "G"
-                        } else if e.contains::<ChildCompH>() {
-                            "H"
-                        } else {
-                            "Unknown"
-                        }
-                    })
-                    .collect()
+                    .collect::<Vec<_>>();
+                assert_eq!(children.len(), 3, "Parent should have exactly 3 children.");
+
+                // Verify order and components
+                assert!(
+                    app.world().entity(children[0]).contains::<ChildCompA>(),
+                    "Child 0 should be A"
+                );
+                assert!(
+                    app.world().entity(children[1]).contains::<ChildCompB>(),
+                    "Child 1 should be B"
+                );
+                assert!(
+                    app.world().entity(children[2]).contains::<ChildCompC>(),
+                    "Child 2 should be C"
+                );
+
+                // Verify parent relationship from each child's perspective
+                let mut parent_rel_query = app.world_mut().query::<&bevy::prelude::ChildOf>();
+                for child_entity in children.into_iter() {
+                    assert_eq!(
+                        parent_rel_query.get(app.world(), child_entity).unwrap().parent(),
+                        parent_entity
+                    );
+                }
+
+                app.world_mut().entity_mut(parent_entity).despawn();
+                app.update();
             }
 
-            #[derive(Resource, Default, Deref, DerefMut, Clone)]
-            struct SignalTrigger(bool);
-            app.init_resource::<SignalTrigger>();
+            // --- 3. TEST CASE: Empty Iterator ---
+            // Verifies that providing an empty iterator results in no children being added.
+            {
+                // The type hint is needed for an empty vec.
+                let parent_builder_empty = JonmoBuilder::new()
+                    .insert(ParentComp)
+                    .children(vec![] as Vec<JonmoBuilder>);
+                let parent_entity_empty = parent_builder_empty.spawn(app.world_mut());
+                app.update();
+                assert!(
+                    app.world().get::<Children>(parent_entity_empty).is_none(),
+                    "Parent with empty children iterator should not have a Children component."
+                );
 
-            let parent_builder = JonmoBuilder::new()
-                .insert(ParentComp)
-                .child(JonmoBuilder::new().insert(ChildCompA)) // Block 0, size 1
-                .children([
-                    // Block 1, size 2
-                    JonmoBuilder::new().insert(ChildCompB),
-                    JonmoBuilder::new().insert(ChildCompC),
-                ])
-                .child_signal(
-                    // Block 2, size 0 -> 1
-                    SignalBuilder::from_resource::<SignalTrigger>().map_in(|trigger: SignalTrigger| {
-                        if trigger.0 {
-                            Some(JonmoBuilder::new().insert(ChildCompD))
-                        } else {
-                            None
-                        }
-                    }),
-                )
-                .children(vec![
-                    // Block 3, size 3
-                    JonmoBuilder::new().insert(ChildCompE),
-                    JonmoBuilder::new().insert(ChildCompF),
-                    JonmoBuilder::new().insert(ChildCompG),
-                ])
-                .child(JonmoBuilder::new().insert(ChildCompH)); // Block 4, size 1
+                app.world_mut().entity_mut(parent_entity_empty).despawn();
+                app.update();
+            }
 
-            let parent_entity = parent_builder.spawn(app.world_mut());
+            // --- 4. TEST CASE: Complex Children and Cleanup ---
+            // Verifies that children can have their own complex logic (signals, hierarchy) and that
+            // they are properly cleaned up when the parent is despawned.
+            {
+                let complex_child_builder = JonmoBuilder::new()
+                    .insert(ChildCompD)
+                    .child(JonmoBuilder::new().insert(GrandchildComp)) // Nested child
+                    .component_signal_from_parent(|parent_signal| {
+                        // Signal reading from parent
+                        parent_signal
+                            .component::<SourceComp>()
+                            .map_in(|source: SourceComp| Some(TargetComp(source.0 * 10)))
+                    });
+
+                let parent_builder_complex = JonmoBuilder::new()
+                    .insert((ParentComp, SourceComp(5)))
+                    .children(vec![complex_child_builder]);
+
+                let parent_entity_complex = parent_builder_complex.spawn(app.world_mut());
+                app.update();
+
+                let complex_children = app.world().get::<Children>(parent_entity_complex).unwrap();
+                let complex_child_entity = complex_children[0];
+
+                // Verify signal ran correctly
+                assert_eq!(
+                    app.world().get::<TargetComp>(complex_child_entity),
+                    Some(&TargetComp(50))
+                );
 
-            // Test Initial Order (Signal is false)
-            app.update();
-            assert_eq!(
-                get_ordered_child_markers(app.world(), parent_entity),
-                vec!["A", "B", "C", "E", "F", "G", "H"],
-                "Initial mixed child order is incorrect"
-            );
-            assert_eq!(app.world().get::<Children>(parent_entity).unwrap().len(), 7);
+                // Verify nested hierarchy
+                let grandchild_entity = app.world().get::<Children>(complex_child_entity).unwrap()[0];
+                assert!(app.world().entity(grandchild_entity).contains::<GrandchildComp>());
 
-            // Test Order After Signal Trigger
-            app.world_mut().resource_mut::<SignalTrigger>().0 = true;
-            app.update();
-            assert_eq!(
-                get_ordered_child_markers(app.world(), parent_entity),
-                vec!["A", "B", "C", "D", "E", "F", "G", "H"],
-                "Mixed child order after signal trigger is incorrect"
-            );
-            assert_eq!(app.world().get::<Children>(parent_entity).unwrap().len(), 8);
+                // Test reactivity
+                app.world_mut().get_mut::<SourceComp>(parent_entity_complex).unwrap().0 = 7;
+                app.update();
+                assert_eq!(
+                    app.world().get::<TargetComp>(complex_child_entity),
+                    Some(&TargetComp(70)),
+                    "Signal did not react to parent's component change."
+                );
 
-            // Test Order After Signal Un-triggers
-            app.world_mut().resource_mut::<SignalTrigger>().0 = false;
-            app.update();
-            assert_eq!(
-                get_ordered_child_markers(app.world(), parent_entity),
-                vec!["A", "B", "C", "E", "F", "G", "H"],
-                "Mixed child order after signal un-triggers is incorrect"
-            );
-            assert_eq!(app.world().get::<Children>(parent_entity).unwrap().len(), 7);
+                // Test cleanup
+                app.world_mut().entity_mut(parent_entity_complex).despawn();
+                app.update();
+
+                assert!(
+                    app.world().get_entity(complex_child_entity).is_err(),
+                    "Complex child should be despawned with parent."
+                );
+                assert!(
+                    app.world().get_entity(grandchild_entity).is_err(),
+                    "Grandchild should be despawned with parent."
+                );
+            }
+
+            // --- 5. TEST CASE: Mixed Ordering with Other Child Methods ---
+            // This is a critical test to ensure the internal offset calculation is correct when
+            // `children` is mixed with `child`, `child_signal`, etc.
+            {
+                // Helper to verify the exact order of children by their components.
+                fn get_ordered_child_markers(world: &World, parent: Entity) -> Vec<&'static str> {
+                    let Some(children) = world.get::<Children>(parent) else {
+                        return vec![];
+                    };
+                    children
+                        .iter()
+                        .map(|child_entity| {
+                            let e = world.entity(child_entity);
+                            if e.contains::<ChildCompA>() {
+                                "A"
+                            } else if e.contains::<ChildCompB>() {
+                                "B"
+                            } else if e.contains::<ChildCompC>() {
+                                "C"
+                            } else if e.contains::<ChildCompD>() {
+                                "D"
+                            } else if e.contains::<ChildCompE>() {
+                                "E"
+                            } else if e.contains::<ChildCompF>() {
+                                "F"
+                            } else if e.contains::<ChildCompG>() {
+                                "G"
+                            } else if e.contains::<ChildCompH>() {
+                                "H"
+                            } else {
+                                "Unknown"
+                            }
+                        })
+                        .collect()
+                }
+
+                #[derive(Resource, Default, Deref, DerefMut, Clone)]
+                struct SignalTrigger(bool);
+                app.init_resource::<SignalTrigger>();
+
+                let parent_builder = JonmoBuilder::new()
+                    .insert(ParentComp)
+                    .child(JonmoBuilder::new().insert(ChildCompA)) // Block 0, size 1
+                    .children([
+                        // Block 1, size 2
+                        JonmoBuilder::new().insert(ChildCompB),
+                        JonmoBuilder::new().insert(ChildCompC),
+                    ])
+                    .child_signal(
+                        // Block 2, size 0 -> 1
+                        SignalBuilder::from_resource::<SignalTrigger>().map_in(|trigger: SignalTrigger| {
+                            if trigger.0 {
+                                Some(JonmoBuilder::new().insert(ChildCompD))
+                            } else {
+                                None
+                            }
+                        }),
+                    )
+                    .children(vec![
+                        // Block 3, size 3
+                        JonmoBuilder::new().insert(ChildCompE),
+                        JonmoBuilder::new().insert(ChildCompF),
+                        JonmoBuilder::new().insert(ChildCompG),
+                    ])
+                    .child(JonmoBuilder::new().insert(ChildCompH)); // Block 4, size 1
+
+                let parent_entity = parent_builder.spawn(app.world_mut());
+
+                // Test Initial Order (Signal is false)
+                app.update();
+                assert_eq!(
+                    get_ordered_child_markers(app.world(), parent_entity),
+                    vec!["A", "B", "C", "E", "F", "G", "H"],
+                    "Initial mixed child order is incorrect"
+                );
+                assert_eq!(app.world().get::<Children>(parent_entity).unwrap().len(), 7);
+
+                // Test Order After Signal Trigger
+                app.world_mut().resource_mut::<SignalTrigger>().0 = true;
+                app.update();
+                assert_eq!(
+                    get_ordered_child_markers(app.world(), parent_entity),
+                    vec!["A", "B", "C", "D", "E", "F", "G", "H"],
+                    "Mixed child order after signal trigger is incorrect"
+                );
+                assert_eq!(app.world().get::<Children>(parent_entity).unwrap().len(), 8);
+
+                // Test Order After Signal Un-triggers
+                app.world_mut().resource_mut::<SignalTrigger>().0 = false;
+                app.update();
+                assert_eq!(
+                    get_ordered_child_markers(app.world(), parent_entity),
+                    vec!["A", "B", "C", "E", "F", "G", "H"],
+                    "Mixed child order after signal un-triggers is incorrect"
+                );
+                assert_eq!(app.world().get::<Children>(parent_entity).unwrap().len(), 7);
+            }
         }
+
+        cleanup()
     }
 
     /// Helper to get a Vec of all children's entity IDs.
@@ -2940,194 +3006,189 @@ mod tests {
 
     #[test]
     fn test_children_signal_vec() {
-        // --- 1. SETUP ---
-        let mut app = create_test_app();
-        let source_vec = MutableVec::from(vec![10u32, 20u32]);
+        {
+            // --- 1. SETUP ---
+            let mut app = create_test_app();
+            let source_vec = MutableVecBuilder::from([10u32, 20u32]).spawn(app.world_mut());
 
-        // A factory function to create a simple JonmoBuilder for a reactive child.
-        let child_builder_factory = |id: u32| JonmoBuilder::new().insert(ReactiveChild(id));
+            // A factory function to create a simple JonmoBuilder for a reactive child.
+            let child_builder_factory = |id: u32| JonmoBuilder::new().insert(ReactiveChild(id));
 
-        // The SignalVec that will drive the children.
-        let children_signal = source_vec.signal_vec().map_in(child_builder_factory);
+            // The SignalVec that will drive the children.
+            let children_signal = source_vec.signal_vec().map_in(child_builder_factory);
 
-        // The parent builder, with static children sandwiching the reactive ones to test ordering.
-        let parent_builder = JonmoBuilder::new()
-            .insert(ParentComp)
-            .child(JonmoBuilder::new().insert(StaticChildBefore))
-            .children_signal_vec(children_signal)
-            .child(JonmoBuilder::new().insert(StaticChildAfter));
+            // The parent builder, with static children sandwiching the reactive ones to test ordering.
+            let parent_builder = JonmoBuilder::new()
+                .insert(ParentComp)
+                .child(JonmoBuilder::new().insert(StaticChildBefore))
+                .children_signal_vec(children_signal)
+                .child(JonmoBuilder::new().insert(StaticChildAfter));
 
-        let parent_entity = parent_builder.spawn(app.world_mut());
+            let parent_entity = parent_builder.spawn(app.world_mut());
 
-        // --- 2. INITIAL STATE ---
-        // The first update runs the on_spawn closures and processes the initial `Replace` diff.
-        app.update();
-        assert_eq!(
-            get_all_child_types(app.world_mut(), parent_entity),
-            vec!["StaticBefore", "Reactive(10)", "Reactive(20)", "StaticAfter"],
-            "Initial child order and content is incorrect."
-        );
+            // --- 2. INITIAL STATE ---
+            // The first update runs the on_spawn closures and processes the initial `Replace` diff.
+            app.update();
+            assert_eq!(
+                get_all_child_types(app.world_mut(), parent_entity),
+                vec!["StaticBefore", "Reactive(10)", "Reactive(20)", "StaticAfter"],
+                "Initial child order and content is incorrect."
+            );
 
-        // --- 3. TEST `PUSH` ---
-        source_vec.write().push(30);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_all_child_types(app.world_mut(), parent_entity),
-            vec![
-                "StaticBefore",
-                "Reactive(10)",
-                "Reactive(20)",
-                "Reactive(30)",
-                "StaticAfter"
-            ],
-            "State after Push is incorrect."
-        );
+            // --- 3. TEST `PUSH` ---
+            source_vec.write(app.world_mut()).push(30);
+            app.update();
+            assert_eq!(
+                get_all_child_types(app.world_mut(), parent_entity),
+                vec![
+                    "StaticBefore",
+                    "Reactive(10)",
+                    "Reactive(20)",
+                    "Reactive(30)",
+                    "StaticAfter"
+                ],
+                "State after Push is incorrect."
+            );
 
-        // --- 4. TEST `INSERT_AT` ---
-        source_vec.write().insert(1, 15); // Insert 15 between 10 and 20
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_all_child_types(app.world_mut(), parent_entity),
-            vec![
-                "StaticBefore",
-                "Reactive(10)",
-                "Reactive(15)",
-                "Reactive(20)",
-                "Reactive(30)",
-                "StaticAfter"
-            ],
-            "State after InsertAt is incorrect."
-        );
-
-        // --- 5. TEST `UPDATE_AT` ---
-        let old_child_entities = get_children_entities(app.world_mut(), parent_entity);
-        let entity_to_be_replaced = old_child_entities[3]; // The "Reactive(20)" entity
-        source_vec.write().set(2, 25); // Update 20 to 25
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_all_child_types(app.world_mut(), parent_entity),
-            vec![
-                "StaticBefore",
-                "Reactive(10)",
-                "Reactive(15)",
-                "Reactive(25)",
-                "Reactive(30)",
-                "StaticAfter"
-            ],
-            "State after UpdateAt is incorrect."
-        );
-        assert!(
-            app.world().get_entity(entity_to_be_replaced).is_err(),
-            "Old child entity should be despawned after UpdateAt."
-        );
+            // --- 4. TEST `INSERT_AT` ---
+            source_vec.write(app.world_mut()).insert(1, 15); // Insert 15 between 10 and 20
+            app.update();
+            assert_eq!(
+                get_all_child_types(app.world_mut(), parent_entity),
+                vec![
+                    "StaticBefore",
+                    "Reactive(10)",
+                    "Reactive(15)",
+                    "Reactive(20)",
+                    "Reactive(30)",
+                    "StaticAfter"
+                ],
+                "State after InsertAt is incorrect."
+            );
 
-        // --- 6. TEST `REMOVE_AT` ---
-        let old_child_entities = get_children_entities(app.world_mut(), parent_entity);
-        let entity_to_be_removed = old_child_entities[2]; // The "Reactive(15)" entity
-        source_vec.write().remove(1); // Remove 15
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_all_child_types(app.world_mut(), parent_entity),
-            vec![
-                "StaticBefore",
-                "Reactive(10)",
-                "Reactive(25)",
-                "Reactive(30)",
-                "StaticAfter"
-            ],
-            "State after RemoveAt is incorrect."
-        );
-        assert!(
-            app.world().get_entity(entity_to_be_removed).is_err(),
-            "Child entity should be despawned after RemoveAt."
-        );
+            // --- 5. TEST `UPDATE_AT` ---
+            let old_child_entities = get_children_entities(app.world_mut(), parent_entity);
+            let entity_to_be_replaced = old_child_entities[3]; // The "Reactive(20)" entity
+            source_vec.write(app.world_mut()).set(2, 25); // Update 20 to 25
+            app.update();
+            assert_eq!(
+                get_all_child_types(app.world_mut(), parent_entity),
+                vec![
+                    "StaticBefore",
+                    "Reactive(10)",
+                    "Reactive(15)",
+                    "Reactive(25)",
+                    "Reactive(30)",
+                    "StaticAfter"
+                ],
+                "State after UpdateAt is incorrect."
+            );
+            assert!(
+                app.world().get_entity(entity_to_be_replaced).is_err(),
+                "Old child entity should be despawned after UpdateAt."
+            );
 
-        // --- 7. TEST `MOVE` ---
-        source_vec.write().move_item(2, 0); // Move 30 (now at index 2) to the front
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_all_child_types(app.world_mut(), parent_entity),
-            vec![
-                "StaticBefore",
-                "Reactive(30)",
-                "Reactive(10)",
-                "Reactive(25)",
-                "StaticAfter"
-            ],
-            "State after Move is incorrect."
-        );
-
-        // --- 8. TEST `POP` ---
-        let old_child_entities = get_children_entities(app.world_mut(), parent_entity);
-        let entity_to_be_popped = old_child_entities[3]; // The "Reactive(25)" entity
-        source_vec.write().pop(); // Removes 25
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_all_child_types(app.world_mut(), parent_entity),
-            vec!["StaticBefore", "Reactive(30)", "Reactive(10)", "StaticAfter"],
-            "State after Pop is incorrect."
-        );
-        assert!(
-            app.world().get_entity(entity_to_be_popped).is_err(),
-            "Child entity should be despawned after Pop."
-        );
+            // --- 6. TEST `REMOVE_AT` ---
+            let old_child_entities = get_children_entities(app.world_mut(), parent_entity);
+            let entity_to_be_removed = old_child_entities[2]; // The "Reactive(15)" entity
+            source_vec.write(app.world_mut()).remove(1); // Remove 15
+            app.update();
+            assert_eq!(
+                get_all_child_types(app.world_mut(), parent_entity),
+                vec![
+                    "StaticBefore",
+                    "Reactive(10)",
+                    "Reactive(25)",
+                    "Reactive(30)",
+                    "StaticAfter"
+                ],
+                "State after RemoveAt is incorrect."
+            );
+            assert!(
+                app.world().get_entity(entity_to_be_removed).is_err(),
+                "Child entity should be despawned after RemoveAt."
+            );
 
-        // --- 9. TEST `CLEAR` ---
-        let reactive_children_before_clear = get_children_entities(app.world_mut(), parent_entity)
-            .into_iter()
-            .filter(|e| app.world().get::<ReactiveChild>(*e).is_some())
-            .collect::<Vec<_>>();
-        source_vec.write().clear();
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_all_child_types(app.world_mut(), parent_entity),
-            vec!["StaticBefore", "StaticAfter"],
-            "State after Clear is incorrect."
-        );
-        for child in reactive_children_before_clear {
+            // --- 7. TEST `MOVE` ---
+            source_vec.write(app.world_mut()).move_item(2, 0); // Move 30 (now at index 2) to the front
+            app.update();
+            assert_eq!(
+                get_all_child_types(app.world_mut(), parent_entity),
+                vec![
+                    "StaticBefore",
+                    "Reactive(30)",
+                    "Reactive(10)",
+                    "Reactive(25)",
+                    "StaticAfter"
+                ],
+                "State after Move is incorrect."
+            );
+
+            // --- 8. TEST `POP` ---
+            let old_child_entities = get_children_entities(app.world_mut(), parent_entity);
+            let entity_to_be_popped = old_child_entities[3]; // The "Reactive(25)" entity
+            source_vec.write(app.world_mut()).pop(); // Removes 25
+            app.update();
+            assert_eq!(
+                get_all_child_types(app.world_mut(), parent_entity),
+                vec!["StaticBefore", "Reactive(30)", "Reactive(10)", "StaticAfter"],
+                "State after Pop is incorrect."
+            );
             assert!(
-                app.world().get_entity(child).is_err(),
-                "All reactive children should be despawned after Clear."
+                app.world().get_entity(entity_to_be_popped).is_err(),
+                "Child entity should be despawned after Pop."
             );
-        }
 
-        // --- 10. TEST `REPLACE` (after Clear) ---
-        source_vec.write().replace(vec![100, 200]);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_all_child_types(app.world_mut(), parent_entity),
-            vec!["StaticBefore", "Reactive(100)", "Reactive(200)", "StaticAfter"],
-            "State after Replace is incorrect."
-        );
+            // --- 9. TEST `CLEAR` ---
+            let reactive_children_before_clear = get_children_entities(app.world_mut(), parent_entity)
+                .into_iter()
+                .filter(|e| app.world().get::<ReactiveChild>(*e).is_some())
+                .collect::<Vec<_>>();
+            source_vec.write(app.world_mut()).clear();
+            app.update();
+            assert_eq!(
+                get_all_child_types(app.world_mut(), parent_entity),
+                vec!["StaticBefore", "StaticAfter"],
+                "State after Clear is incorrect."
+            );
+            for child in reactive_children_before_clear {
+                assert!(
+                    app.world().get_entity(child).is_err(),
+                    "All reactive children should be despawned after Clear."
+                );
+            }
 
-        // --- 11. TEST PARENT DESPAWN ---
-        let all_children_before_despawn = get_children_entities(app.world_mut(), parent_entity);
-        app.world_mut().entity_mut(parent_entity).despawn();
-        app.update(); // Process despawn commands
+            // --- 10. TEST `REPLACE` (after Clear) ---
+            source_vec.write(app.world_mut()).replace(vec![100, 200]);
+            app.update();
+            assert_eq!(
+                get_all_child_types(app.world_mut(), parent_entity),
+                vec!["StaticBefore", "Reactive(100)", "Reactive(200)", "StaticAfter"],
+                "State after Replace is incorrect."
+            );
+
+            // --- 11. TEST PARENT DESPAWN ---
+            let all_children_before_despawn = get_children_entities(app.world_mut(), parent_entity);
+            app.world_mut().entity_mut(parent_entity).despawn();
+            app.update(); // Process despawn commands
 
-        assert!(
-            app.world().get_entity(parent_entity).is_err(),
-            "Parent entity should be despawned."
-        );
-        for child in all_children_before_despawn {
             assert!(
-                app.world().get_entity(child).is_err(),
-                "All children (static and reactive) should be despawned with parent."
+                app.world().get_entity(parent_entity).is_err(),
+                "Parent entity should be despawned."
             );
+            for child in all_children_before_despawn {
+                assert!(
+                    app.world().get_entity(child).is_err(),
+                    "All children (static and reactive) should be despawned with parent."
+                );
+            }
+
+            // Verify signal cleanup by flushing one more change. This should not panic.
+            source_vec.write(app.world_mut()).push(999);
+            app.update();
+            // The test passes if the above update doesn't panic.
         }
 
-        // Verify signal cleanup by flushing one more change. This should not panic.
-        source_vec.write().push(999);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        // The test passes if the above update doesn't panic.
+        cleanup()
     }
 }
diff --git a/src/graph.rs b/src/graph.rs
index 7bf8911..7833efc 100644
--- a/src/graph.rs
+++ b/src/graph.rs
@@ -402,7 +402,7 @@ impl Drop for LazySignal {
         if self.inner.references.fetch_sub(1, Ordering::SeqCst) <= 2
             && let LazySystem::Registered(signal) = *self.inner.system.read().unwrap()
         {
-            CLEANUP_SIGNALS.lock().unwrap().push(signal);
+            STALE_SIGNALS.lock().unwrap().push(signal);
         }
     }
 }
@@ -410,10 +410,10 @@ impl Drop for LazySignal {
 #[derive(Component)]
 pub(crate) struct LazySignalHolder(LazySignal);
 
-static CLEANUP_SIGNALS: LazyLock<Mutex<Vec<SignalSystem>>> = LazyLock::new(|| Mutex::new(Vec::new()));
+pub(crate) static STALE_SIGNALS: LazyLock<Mutex<Vec<SignalSystem>>> = LazyLock::new(|| Mutex::new(Vec::new()));
 
-pub(crate) fn flush_cleanup_signals(world: &mut World) {
-    let signals = CLEANUP_SIGNALS.lock().unwrap().drain(..).collect::<Vec<_>>();
+pub(crate) fn despawn_stale_signals(world: &mut World) {
+    let signals = STALE_SIGNALS.lock().unwrap().drain(..).collect::<Vec<_>>();
     for signal in signals {
         if let Ok(entity) = world.get_entity_mut(*signal)
             && let Some(registration_count) = entity.get::<SignalRegistrationCount>()
diff --git a/src/lib.rs b/src/lib.rs
index cad21f1..61dfde3 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -4,11 +4,10 @@
     feature = "document-features",
     doc = document_features::document_features!()
 )]
-#![no_std]
+#![cfg_attr(not(test), no_std)]
 
 extern crate alloc;
 
-use alloc::vec::Vec;
 use bevy_app::prelude::*;
 use bevy_ecs::prelude::*;
 
@@ -21,39 +20,32 @@ pub mod signal_vec;
 #[allow(missing_docs)]
 pub mod utils;
 
-fn trigger_replays<ReplayTrigger: Component + signal_vec::Replayable>(world: &mut World) {
-    let triggers: Vec<Entity> = world
-        .query_filtered::<Entity, With<ReplayTrigger>>()
-        .iter(world)
-        .collect();
-    for trigger_entity in triggers {
-        if let Some(trigger_component) = world
-            .get_entity_mut(trigger_entity)
-            .ok()
-            .and_then(|mut e| e.take::<ReplayTrigger>())
-        {
-            trigger_component.trigger()(world);
-        }
-    }
-}
-
 /// Includes the systems required for [jonmo](crate) to function.
 #[derive(Default)]
 pub struct JonmoPlugin;
 
+/// [`SystemSet`] that can be used to schedule systems around signal processing.
+#[derive(SystemSet, Debug, Clone, PartialEq, Eq, Hash)]
+pub struct SignalProcessing;
+
 impl Plugin for JonmoPlugin {
     fn build(&self, app: &mut App) {
         app.add_systems(
             Last,
             (
                 (
-                    trigger_replays::<signal_vec::VecReplayTrigger>,
-                    trigger_replays::<signal_map::MapReplayTrigger>,
+                    signal_vec::trigger_replays::<signal_vec::VecReplayTrigger>,
+                    signal_vec::trigger_replays::<signal_map::MapReplayTrigger>,
                 ),
                 graph::process_signal_graph,
-                graph::flush_cleanup_signals,
+                (
+                    graph::despawn_stale_signals,
+                    signal_vec::despawn_stale_mutable_vecs,
+                    signal_map::despawn_stale_mutable_btree_maps,
+                ),
             )
-                .chain(),
+                .chain()
+                .in_set(SignalProcessing),
         );
     }
 }
@@ -66,8 +58,11 @@ pub mod prelude {
         JonmoPlugin,
         graph::SignalHandles,
         signal::{IntoSignalEither, Signal, SignalBuilder, SignalEither, SignalExt},
-        signal_map::{MutableBTreeMap, SignalMap, SignalMapExt},
-        signal_vec::{IntoSignalVecEither, MutableVec, SignalVec, SignalVecEither, SignalVecExt},
+        signal_map::{MutableBTreeMap, MutableBTreeMapBuilder, MutableBTreeMapData, SignalMap, SignalMapExt},
+        signal_vec::{
+            IntoSignalVecEither, MutableVec, MutableVecBuilder, MutableVecData, SignalVec, SignalVecEither,
+            SignalVecExt,
+        },
         utils::{LazyEntity, clone},
     };
     #[doc(no_inline)]
diff --git a/src/signal.rs b/src/signal.rs
index f6d9106..9eda93d 100644
--- a/src/signal.rs
+++ b/src/signal.rs
@@ -58,13 +58,13 @@ impl<U: 'static> Signal for Box<dyn Signal<Item = U> + Send + Sync> {
 ///
 /// Relevant in contexts where some function may require a [`Clone`] [`Signal`], but the concrete
 /// type can't be known at compile-time.
-pub trait SignalClone: Signal + DynClone {}
+pub trait SignalDynClone: Signal + DynClone {}
 
-clone_trait_object!(< T > SignalClone < Item = T >);
+clone_trait_object!(<T> SignalDynClone<Item = T>);
 
-impl<T: Signal + Clone + 'static> SignalClone for T {}
+impl<T: Signal + Clone + 'static> SignalDynClone for T {}
 
-impl<O: 'static> Signal for Box<dyn SignalClone<Item = O> + Send + Sync> {
+impl<O: 'static> Signal for Box<dyn SignalDynClone<Item = O> + Send + Sync> {
     type Item = O;
 
     fn register_boxed_signal(self: Box<Self>, world: &mut World) -> SignalHandle {
@@ -628,7 +628,7 @@ impl SignalBuilder {
 
     /// Creates a [`Source`] signal from a [`LazyEntity`].
     pub fn from_lazy_entity(entity: LazyEntity) -> Source<Entity> {
-        Self::from_system(move |_: In<()>| entity.get())
+        Self::from_system(move |_: In<()>| *entity)
     }
 
     /// Creates a [`Source`] signal from an [`Entity`]'s `generations`-th generation ancestor's
@@ -675,7 +675,7 @@ impl SignalBuilder {
     where
         C: Component + Clone,
     {
-        Self::from_system(move |_: In<()>, components: Query<&C>| components.get(entity.get()).ok().cloned())
+        Self::from_system(move |_: In<()>, components: Query<&C>| components.get(*entity).ok().cloned())
     }
 
     /// Creates a [`Source`] signal from an [`Entity`] and a [`Component`], always outputting an
@@ -693,7 +693,7 @@ impl SignalBuilder {
     where
         C: Component + Clone,
     {
-        Self::from_system(move |_: In<()>, components: Query<&C>| Some(components.get(entity.get()).ok().cloned()))
+        Self::from_system(move |_: In<()>, components: Query<&C>| Some(components.get(*entity).ok().cloned()))
     }
 
     /// Creates a signal from a [`Resource`], terminating for the frame if the [`Resource`] does not
@@ -950,8 +950,8 @@ pub trait SignalExt: Signal {
     ///
     /// SignalBuilder::from_system({
     ///     move |_: In<()>, mut state: Local<usize>| {
-    ///        *state += 1;
-    ///        *state / 2
+    ///         *state += 1;
+    ///         *state / 2
     ///     }
     /// })
     /// .dedupe(); // outputs `0`, `1`, `2`, `3`, ...
@@ -993,8 +993,8 @@ pub trait SignalExt: Signal {
     ///
     /// SignalBuilder::from_system({
     ///     move |_: In<()>, mut state: Local<usize>| {
-    ///        *state += 1;
-    ///        *state / 2
+    ///         *state += 1;
+    ///         *state / 2
     ///     }
     /// })
     /// .first(); // outputs `0` then terminates forever
@@ -1091,8 +1091,8 @@ pub trait SignalExt: Signal {
     ///
     /// SignalBuilder::from_system({
     ///     move |_: In<()>, mut state: Local<usize>| {
-    ///        *state += 1;
-    ///        *state % 2
+    ///         *state += 1;
+    ///         *state % 2
     ///     }
     /// })
     /// .filter(|In(i): In<usize>| i % 2 == 0); // outputs `2`, `4`, `6`, `8`, ...
@@ -1195,7 +1195,7 @@ pub trait SignalExt: Signal {
     ///             SignalBuilder::from_system(|_: In<()>| 1)
     ///         } else {
     ///             SignalBuilder::from_system(|_: In<()>| 2)
-    ///        }
+    ///         }
     ///     })
     ///     .flatten();
     ///
@@ -1331,16 +1331,16 @@ pub trait SignalExt: Signal {
     ///
     /// let mut world = World::new();
     /// world.insert_resource(Toggle(false));
-    /// let signal = SignalBuilder::from_resource::<Toggle>()
-    ///     .dedupe()
-    ///     .switch(move |In(toggle): In<Toggle>| {
-    ///         if toggle.0 {
-    ///             SignalBuilder::from_system(|_: In<()>| 1)
-    ///         } else {
-    ///             SignalBuilder::from_system(|_: In<()>| 2)
-    ///         }
-    ///     }
-    /// );
+    /// let signal =
+    ///     SignalBuilder::from_resource::<Toggle>()
+    ///         .dedupe()
+    ///         .switch(move |In(toggle): In<Toggle>| {
+    ///             if toggle.0 {
+    ///                 SignalBuilder::from_system(|_: In<()>| 1)
+    ///             } else {
+    ///                 SignalBuilder::from_system(|_: In<()>| 2)
+    ///             }
+    ///         });
     /// // `signal` outputs `2`
     /// world.resource_mut::<Toggle>().0 = true;
     /// // `signal` outputs `1`
@@ -1370,21 +1370,18 @@ pub trait SignalExt: Signal {
     /// #[derive(Resource, Clone, PartialEq)]
     /// struct Toggle(bool);
     ///
-    /// let list_a = MutableVec::from([1, 2, 3]);
-    /// let list_b = MutableVec::from([10, 20]);
-    ///
     /// let mut world = World::new();
     /// world.insert_resource(Toggle(false));
+    ///
     /// let signal = SignalBuilder::from_resource::<Toggle>()
     ///     .dedupe()
-    ///     .switch_signal_vec(move |In(toggle): In<Toggle>| {
+    ///     .switch_signal_vec(move |In(toggle): In<Toggle>, world: &mut World| {
     ///         if toggle.0 {
-    ///             list_a.signal_vec()
+    ///             MutableVecBuilder::from([1, 2, 3]).spawn(world).signal_vec()
     ///         } else {
-    ///             list_b.signal_vec()
+    ///             MutableVecBuilder::from([10, 20]).spawn(world).signal_vec()
     ///         }
-    ///     }
-    /// );
+    ///     });
     /// // `signal` outputs `SignalVec -> [10, 20]`
     /// world.resource_mut::<Toggle>().0 = true;
     /// // `signal` outputs `SignalVec -> [1, 2, 3]`
@@ -1406,7 +1403,7 @@ pub trait SignalExt: Signal {
             let output_system_entity = LazyEntity::new();
             let output_system = lazy_signal_from_system::<_, Vec<VecDiff<S::Item>>, _, _, _>(
                 clone!((output_system_entity) move |_: In<()>, mut q: Query<&mut SwitcherQueue<S::Item>>| {
-                    if let Ok(mut queue) = q.get_mut(output_system_entity.get()) {
+                    if let Ok(mut queue) = q.get_mut(*output_system_entity) {
                         if queue.0.is_empty() {
                             None
                         } else {
@@ -1553,14 +1550,11 @@ pub trait SignalExt: Signal {
     ///
     /// SignalBuilder::from_system({
     ///     move |_: In<()>, mut state: Local<bool>| {
-    ///        *state = !*state;
-    ///        *state
+    ///         *state = !*state;
+    ///         *state
     ///     }
     /// })
-    /// .map_bool(
-    ///     |_: In<()>| 1,
-    ///     |_: In<()>| 0,
-    /// ); // outputs `1`, `0`, `1`, `0`, ...
+    /// .map_bool(|_: In<()>| 1, |_: In<()>| 0); // outputs `1`, `0`, `1`, `0`, ...
     /// ```
     fn map_bool<O, IOO, TF, FF, TM, FM>(self, true_system: TF, false_system: FF) -> MapBool<Self, O>
     where
@@ -1607,13 +1601,11 @@ pub trait SignalExt: Signal {
     ///
     /// SignalBuilder::from_system({
     ///     move |_: In<()>, mut state: Local<bool>| {
-    ///        *state = !*state;
-    ///        *state
+    ///         *state = !*state;
+    ///         *state
     ///     }
     /// })
-    /// .map_true(
-    ///     |_: In<()>| 1,
-    /// ); // outputs `1`, terminates, outputs `1`, terminates, ...
+    /// .map_true(|_: In<()>| 1); // outputs `1`, terminates, outputs `1`, terminates, ...
     /// ```
     fn map_true<O, F, M>(self, system: F) -> MapTrue<Self, O>
     where
@@ -1655,13 +1647,11 @@ pub trait SignalExt: Signal {
     ///
     /// SignalBuilder::from_system({
     ///     move |_: In<()>, mut state: Local<bool>| {
-    ///        *state = !*state;
-    ///        *state
+    ///         *state = !*state;
+    ///         *state
     ///     }
     /// })
-    /// .map_false(
-    ///     |_: In<()>| 1,
-    /// ); // terminates, outputs `1`, terminates, outputs `1`, ...
+    /// .map_false(|_: In<()>| 1); // terminates, outputs `1`, terminates, outputs `1`, ...
     /// ```
     fn map_false<O, F, M>(self, system: F) -> MapFalse<Self, O>
     where
@@ -1801,13 +1791,11 @@ pub trait SignalExt: Signal {
     ///
     /// SignalBuilder::from_system({
     ///     move |_: In<()>, mut state: Local<Option<bool>>| {
-    ///        *state = if state.is_some() { None } else { Some(true) };
-    ///        *state
+    ///         *state = if state.is_some() { None } else { Some(true) };
+    ///         *state
     ///     }
     /// })
-    /// .map_none(
-    ///     |_: In<()>| false
-    /// ); // terminates, outputs `false`, terminates, outputs `false`, ...
+    /// .map_none(|_: In<()>| false); // terminates, outputs `false`, terminates, outputs `false`, ...
     /// ```
     fn map_none<I, O, F, M>(self, none_system: F) -> MapNone<Self, O>
     where
@@ -1853,9 +1841,12 @@ pub trait SignalExt: Signal {
     ///
     /// SignalBuilder::from_system({
     ///     move |_: In<()>, mut state: Local<Vec<usize>>| {
-    ///        let new = state.get(state.len().saturating_sub(1)).map(|last| last + 1).unwrap_or_default();
-    ///        state.push(new);
-    ///        state.clone()
+    ///         let new = state
+    ///             .get(state.len().saturating_sub(1))
+    ///             .map(|last| last + 1)
+    ///             .unwrap_or_default();
+    ///         state.push(new);
+    ///         state.clone()
     ///     }
     /// })
     /// .to_signal_vec(); // outputs a `SignalVec` of `[0]`, `[0, 1]`, `[0, 1, 2]`, `[0, 1, 2, 3]`, ...
@@ -1942,12 +1933,16 @@ pub trait SignalExt: Signal {
     ///
     /// let condition = true;
     /// if condition {
-    ///     SignalBuilder::from_system(|_: In<()>| 1).map_in(|x: i32| x * 2).boxed_clone() // this is a `Map<Source<i32>>`
+    ///     SignalBuilder::from_system(|_: In<()>| 1)
+    ///         .map_in(|x: i32| x * 2)
+    ///         .boxed_clone() // this is a `Map<Source<i32>>`
     /// } else {
-    ///     SignalBuilder::from_system(|_: In<()>| 1).dedupe().boxed_clone() // this is a `Dedupe<Source<i32>>`
+    ///     SignalBuilder::from_system(|_: In<()>| 1)
+    ///         .dedupe()
+    ///         .boxed_clone() // this is a `Dedupe<Source<i32>>`
     /// }; // without the `.boxed_clone()`, the compiler would not allow this
     /// ```
-    fn boxed_clone(self) -> Box<dyn SignalClone<Item = Self::Item>>
+    fn boxed_clone(self) -> Box<dyn SignalDynClone<Item = Self::Item>>
     where
         Self: Sized + Clone,
     {
@@ -1971,9 +1966,9 @@ mod tests {
     use crate::{
         JonmoPlugin,
         graph::{LazySignalHolder, SignalRegistrationCount},
-        prelude::{MutableVec, SignalVecExt, clone},
+        prelude::{SignalVecExt, clone},
         signal::{SignalBuilder, SignalExt, Upstream},
-        signal_vec::VecDiff,
+        signal_vec::{MutableVecBuilder, VecDiff},
         utils::{LazyEntity, SSs},
     };
     use core::{convert::identity, fmt};
@@ -1981,10 +1976,11 @@ mod tests {
     // Import Bevy prelude for MinimalPlugins and other common items
     use bevy::prelude::*;
     use bevy_platform::sync::*;
-    use bevy_time::TimeUpdateStrategy;
+    use bevy_time::TimePlugin;
 
     // Add Duration
     use core::time::Duration;
+    use test_log::test;
 
     // Helper component and resource for testing Add Default
     #[derive(Component, Clone, Debug, PartialEq, Reflect, Default, Resource)]
@@ -2530,326 +2526,213 @@ mod tests {
 
     #[test]
     fn test_switch_signal_vec() {
-        // --- Setup ---
-        let mut app = create_test_app();
-        app.init_resource::<SignalVecOutput<i32>>();
-
-        // Two different data sources to switch between.
-        let list_a = MutableVec::from(vec![10, 20]);
-        let list_b = MutableVec::from(vec![100, 200, 300]);
-
-        // A resource to control which list is active.
-        #[derive(Resource, Clone, Copy, PartialEq, Debug)]
-        enum ListSelector {
-            A,
-            B,
-        }
-
-        app.insert_resource(ListSelector::A);
-
-        // The control signal reads the resource.
-        let control_signal = SignalBuilder::from_system(|_: In<()>, selector: Res<ListSelector>| *selector).dedupe();
-
-        // The signal chain under test.
-        let switched_signal = control_signal.dedupe().switch_signal_vec(
-            clone!((list_a, list_b) move |In(selector): In<ListSelector>| match selector {
-                ListSelector:: A => list_a.signal_vec().map_in(identity).boxed_clone(),
-                ListSelector:: B => list_b.signal_vec().boxed_clone(),
-            }),
-        );
+        {
+            // --- Setup ---
+            let mut app = create_test_app();
+            app.init_resource::<SignalVecOutput<i32>>();
+
+            // Two different data sources to switch between.
+            let list_a = MutableVecBuilder::from([10, 20]).spawn(app.world_mut());
+            let list_b = MutableVecBuilder::from([100, 200, 300]).spawn(app.world_mut());
+
+            // A resource to control which list is active.
+            #[derive(Resource, Clone, Copy, PartialEq, Debug)]
+            enum ListSelector {
+                A,
+                B,
+            }
 
-        // Register the final signal to a capture system.
-        let handle = switched_signal.for_each(capture_vec_output).register(app.world_mut());
+            app.insert_resource(ListSelector::A);
 
-        // --- Test 1: Initial State --- The first update should select List A and emit
-        // its initial state.
-        app.update();
-        let diffs = get_and_clear_vec_output::<i32>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Initial update should produce one diff.");
-        assert_eq!(
-            diffs[0],
-            VecDiff::Replace { values: vec![10, 20] },
-            "Initial state should be a Replace with List A's contents."
-        );
+            // The control signal reads the resource.
+            let control_signal =
+                SignalBuilder::from_system(|_: In<()>, selector: Res<ListSelector>| *selector).dedupe();
 
-        // --- Test 2: Forwarding Diffs from Active List (A) --- A mutation to List A
-        // should be forwarded.
-        list_a.write().push(30);
-        list_a.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_vec_output::<i32>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Push to active list should produce one diff.");
-        assert_eq!(
-            diffs[0],
-            VecDiff::Push { value: 30 },
-            "Should forward Push diff from List A."
-        );
+            // The signal chain under test.
+            let switched_signal = control_signal.dedupe().switch_signal_vec(
+                clone!((list_a, list_b) move |In(selector): In<ListSelector>| match selector {
+                    ListSelector:: A => list_a.signal_vec().map_in(identity).boxed_clone(),
+                    ListSelector:: B => list_b.signal_vec().boxed_clone(),
+                }),
+            );
 
-        // --- Test 3: The Switch to List B --- Change the selector and update. This
-        // should trigger a switch.
-        *app.world_mut().resource_mut::<ListSelector>() = ListSelector::B;
-        app.update();
-        let diffs = get_and_clear_vec_output::<i32>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Switching lists should produce one diff.");
-        assert_eq!(
-            diffs[0],
-            VecDiff::Replace {
-                values: vec![100, 200, 300]
-            },
-            "Switch should emit a Replace with List B's contents."
-        );
+            // Register the final signal to a capture system.
+            let handle = switched_signal.for_each(capture_vec_output).register(app.world_mut());
 
-        // --- Test 4: Ignoring Diffs from Old List (A) --- A mutation to the now-inactive
-        // List A should be ignored. This should not be seen
-        list_a.write().push(99);
-        list_a.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_vec_output::<i32>(app.world_mut());
-        assert!(diffs.is_empty(), "Should ignore diffs from the old, inactive list.");
+            // --- Test 1: Initial State --- The first update should select List A and emit
+            // its initial state.
+            app.update();
+            let diffs = get_and_clear_vec_output::<i32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Initial update should produce one diff.");
+            assert_eq!(
+                diffs[0],
+                VecDiff::Replace { values: vec![10, 20] },
+                "Initial state should be a Replace with List A's contents."
+            );
+
+            // --- Test 2: Forwarding Diffs from Active List (A) --- A mutation to List A
+            // should be forwarded.
+            list_a.write(app.world_mut()).push(30);
+            app.update();
+            let diffs = get_and_clear_vec_output::<i32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Push to active list should produce one diff.");
+            assert_eq!(
+                diffs[0],
+                VecDiff::Push { value: 30 },
+                "Should forward Push diff from List A."
+            );
+
+            // --- Test 3: The Switch to List B --- Change the selector and update. This
+            // should trigger a switch.
+            *app.world_mut().resource_mut::<ListSelector>() = ListSelector::B;
+            app.update();
+            let diffs = get_and_clear_vec_output::<i32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Switching lists should produce one diff.");
+            assert_eq!(
+                diffs[0],
+                VecDiff::Replace {
+                    values: vec![100, 200, 300]
+                },
+                "Switch should emit a Replace with List B's contents."
+            );
 
-        // --- Test 5: Forwarding Diffs from New Active List (B) --- A mutation to List B
-        // should now be forwarded. remove 100
-        list_b.write().remove(0);
-        list_b.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_vec_output::<i32>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "RemoveAt from new active list should produce one diff.");
-        assert_eq!(
-            diffs[0],
-            VecDiff::RemoveAt { index: 0 },
-            "Should forward RemoveAt diff from List B."
-        );
+            // --- Test 4: Ignoring Diffs from Old List (A) --- A mutation to the now-inactive
+            // List A should be ignored. This should not be seen
+            list_a.write(app.world_mut()).push(99);
+            app.update();
+            let diffs = get_and_clear_vec_output::<i32>(app.world_mut());
+            assert!(diffs.is_empty(), "Should ignore diffs from the old, inactive list.");
 
-        // --- Test 6: Memoization (No-Op Switch) --- "Switching" to the already active
-        // list should produce no diffs.
-        *app.world_mut().resource_mut::<ListSelector>() = ListSelector::B;
-        app.update();
-        let diffs = get_and_clear_vec_output::<i32>(app.world_mut());
-        assert!(
-            diffs.is_empty(),
-            "Re-selecting the same list should produce no diffs due to memoization."
-        );
+            // --- Test 5: Forwarding Diffs from New Active List (B) --- A mutation to List B
+            // should now be forwarded. remove 100
+            list_b.write(app.world_mut()).remove(0);
+            app.update();
+            let diffs = get_and_clear_vec_output::<i32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "RemoveAt from new active list should produce one diff.");
+            assert_eq!(
+                diffs[0],
+                VecDiff::RemoveAt { index: 0 },
+                "Should forward RemoveAt diff from List B."
+            );
+
+            // --- Test 6: Memoization (No-Op Switch) --- "Switching" to the already active
+            // list should produce no diffs.
+            *app.world_mut().resource_mut::<ListSelector>() = ListSelector::B;
+            app.update();
+            let diffs = get_and_clear_vec_output::<i32>(app.world_mut());
+            assert!(
+                diffs.is_empty(),
+                "Re-selecting the same list should produce no diffs due to memoization."
+            );
+
+            // --- Test 7: Switch Back to List A --- Switching back should give us the current
+            // state of List A.
+            *app.world_mut().resource_mut::<ListSelector>() = ListSelector::A;
+            app.update();
+            let diffs = get_and_clear_vec_output::<i32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Switching back to A should produce one diff.");
+            assert_eq!(
+                diffs[0],
+                VecDiff::Replace {
+                    values: vec![10, 20, 30, 99],
+                    // Note: includes the `push(30)` from earlier
+                },
+                "Switching back should Replace with the current state of List A."
+            );
+            handle.cleanup(app.world_mut());
+        }
 
-        // --- Test 7: Switch Back to List A --- Switching back should give us the current
-        // state of List A.
-        *app.world_mut().resource_mut::<ListSelector>() = ListSelector::A;
-        app.update();
-        let diffs = get_and_clear_vec_output::<i32>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Switching back to A should produce one diff.");
-        assert_eq!(
-            diffs[0],
-            VecDiff::Replace {
-                values: vec![10, 20, 30, 99],
-                // Note: includes the `push(30)` from earlier
-            },
-            "Switching back should Replace with the current state of List A."
-        );
-        handle.cleanup(app.world_mut());
+        crate::signal_vec::tests::cleanup(true);
     }
 
     #[test]
     fn test_throttle() {
-        let mut app = create_test_app();
+        let mut app = App::new();
+        app.add_plugins((MinimalPlugins.build().disable::<TimePlugin>(), JonmoPlugin));
+        app.init_resource::<Time>(); // manually managing time for the test
         app.init_resource::<SignalOutput<i32>>();
-        let counter = Arc::new(Mutex::new(0));
-        let emit_count = Arc::new(Mutex::new(0));
-
-        // Throttle duration
-        let throttle_duration = Duration::from_millis(100);
-        let signal = SignalBuilder::from_system(clone!((counter) move |_: In<()>| {
-            let mut c = counter.lock().unwrap();
-            *c += 1;
-
-            // Emit 1, 2, 3, 4, 5... rapidly
-            Some(*c)
-        }))
-        .throttle(throttle_duration)
-        .map(clone!((emit_count) move |In(val): In<i32>| {
-            let mut count = emit_count.lock().unwrap();
-            *count += 1;
-
-            // Pass the value through
-            val
-        }))
-        .map(capture_output)
-        .register(app.world_mut());
-
-        // --- Test Execution with Manual Time Control (Revised Assertions) ---
-        //
-        // 1. Initial update: Emit 1, create timer.
-        app.update();
 
-        // Changed assertion description
-        assert_eq!(get_output::<i32>(app.world()), Some(1), "Initial emit (1)");
-        assert_eq!(*emit_count.lock().unwrap(), 1, "Emit count after initial");
-        assert_eq!(*counter.lock().unwrap(), 1, "Source counter after initial");
+        // A simple counter to generate a new value (1, 2, 3...) for each update.
+        let source_signal = SignalBuilder::from_system(|_: In<()>, mut counter: Local<i32>| {
+            *counter += 1;
+            *counter
+        });
 
-        // 2. Advance time > duration (110ms).
-        app.world_mut()
-            .insert_resource(TimeUpdateStrategy::ManualDuration(Duration::from_secs_f32(110.)));
+        let handle = source_signal
+            .throttle(Duration::from_millis(100))
+            .map(capture_output)
+            .register(app.world_mut());
 
-        // 3. Update again: Source emits 2. Time elapsed >= duration. Throttle emits 2.
+        // 1. Initial emission: The first update runs with near-zero delta. The first value should always
+        //    pass.
         app.update();
         assert_eq!(
-            get_output::<i32>(app.world()),
-            Some(2),
-            // EXPECT 2
-            "After 110ms advance, 1st update (emit 2)"
-        );
-        assert_eq!(
-            *emit_count.lock().unwrap(),
-            2,
-            // EXPECT 2
-            "Emit count after 110ms advance, 1st update"
-        );
-        assert_eq!(
-            *counter.lock().unwrap(),
-            2,
-            "Source counter after 110ms advance, 1st update"
+            get_output(app.world()),
+            Some(1),
+            "First value (1) should pass immediately."
         );
-        app.world_mut()
-            .insert_resource(TimeUpdateStrategy::ManualDuration(Duration::from_millis(50)));
+        // Clear the output to prepare for the next check.
+        app.world_mut().resource_mut::<SignalOutput<i32>>().0 = None;
 
-        // 6. Update again: Source emits 4. Time elapsed < duration since last emit. Throttle blocks. Output
-        //    remains 2.
-        app.update();
-        assert_eq!(
-            get_output::<i32>(app.world()),
-            Some(2),
-            // EXPECT 2
-            "After 110ms advance, 2nd update (block 3)"
-        );
-        assert_eq!(
-            *emit_count.lock().unwrap(),
-            2,
-            // EXPECT 2
-            "Emit count after 110ms advance, 2nd update"
-        );
-        assert_eq!(
-            *counter.lock().unwrap(),
-            3,
-            "Source counter after 110ms advance, 2nd update"
-        );
+        // 2. Blocked emission: Manually advance time by 50ms.
         app.world_mut()
-            .insert_resource(TimeUpdateStrategy::ManualDuration(Duration::from_millis(0)));
-
-        // 7. Update again: Source emits 5. Time elapsed < duration since last emit. Throttle blocks. Output
-        //    remains 2.
-        app.update();
+            .resource_mut::<Time>()
+            .advance_by(Duration::from_millis(50));
+        app.update(); // `time.delta()` is now 50ms. The timer ticks but isn't finished.
         assert_eq!(
             get_output::<i32>(app.world()),
-            Some(2),
-            // EXPECT 2
-            "After 50ms advance, 1st update (block 4)"
-        );
-        assert_eq!(
-            *emit_count.lock().unwrap(),
-            2,
-            "Emit count after 50ms advance, 1st update"
-        );
-        assert_eq!(
-            *counter.lock().unwrap(),
-            4,
-            "Source counter after 50ms advance, 1st update"
+            None,
+            "Value (2) emitted after 50ms should be blocked."
         );
 
-        // 8. Advance time > duration again (total 50 + 60 = 110ms since last emit at step 3).
+        // 3. Another blocked emission: Advance time by another 40ms (total 90ms).
         app.world_mut()
-            .insert_resource(TimeUpdateStrategy::ManualDuration(Duration::from_millis(60)));
-
-        // 9. Update again: Source emits 5. Total time elapsed >= duration. Throttle emits 5.
-        app.update();
+            .resource_mut::<Time>()
+            .advance_by(Duration::from_millis(40));
+        app.update(); // `time.delta()` is 40ms. Timer ticks to 90ms. Still not finished.
         assert_eq!(
             get_output::<i32>(app.world()),
-            // Reverted: Expect 5 based on logic and actual output
-            Some(5),
-            // Corrected message to reflect expected value
-            "After 60ms advance, 1st update (emit 5)"
-        );
-        assert_eq!(
-            *emit_count.lock().unwrap(),
-            // Emit count becomes 3
-            3,
-            "Emit count after 60ms advance, 1st update"
-        );
-        assert_eq!(
-            *counter.lock().unwrap(),
-            // Source counter is 5
-            5,
-            "Source counter after 60ms advance, 1st update"
+            None,
+            "Value (3) emitted after 90ms total should be blocked."
         );
+        app.world_mut().entity(**handle);
+        // 4. Allowed emission: Advance time by another 20ms (total 110ms).
         app.world_mut()
-            .insert_resource(TimeUpdateStrategy::ManualDuration(Duration::from_millis(0)));
-
-        // 10. Update again: Source emits 6. Time elapsed < duration since last emit. Throttle
-        //    blocks. Output remains 5.
-        app.update();
-        assert_eq!(
-            get_output::<i32>(app.world()),
-            // Output remains 5
-            Some(5),
-            // EXPECT 5
-            "After 60ms advance, 2nd update (block 6)"
-        );
-        assert_eq!(
-            *emit_count.lock().unwrap(),
-            3,
-            "Emit count after 60ms advance, 2nd update"
-        );
+            .resource_mut::<Time>()
+            .advance_by(Duration::from_millis(20));
+        app.update(); // `time.delta()` is 20ms. Timer ticks to 110ms, which is >= 100ms.
+        // The source signal has been called 4 times now. The value should be 4.
         assert_eq!(
-            *counter.lock().unwrap(),
-            6,
-            "Source counter after 60ms advance, 2nd update"
+            get_output(app.world()),
+            Some(4),
+            "Value (4) should pass after total duration > 100ms."
         );
+        app.world_mut().resource_mut::<SignalOutput<i32>>().0 = None;
 
-        // Add one more step to ensure timer reset correctly
+        // 5. Blocked again: The timer was reset on the last pass. A small advance is not enough.
         app.world_mut()
-            .insert_resource(TimeUpdateStrategy::ManualDuration(Duration::from_millis(110)));
-
-        // 11. Update: Source emits 7. Time >= 100ms. Throttle emits 7.
+            .resource_mut::<Time>()
+            .advance_by(Duration::from_millis(10));
         app.update();
         assert_eq!(
             get_output::<i32>(app.world()),
-            // Expect 7
-            Some(7),
-            "After 110ms advance, 1st update (emit 7)"
-        );
-        assert_eq!(
-            *emit_count.lock().unwrap(),
-            // Emit count becomes 4
-            4,
-            "Emit count after 110ms advance, 1st update"
-        );
-        assert_eq!(
-            *counter.lock().unwrap(),
-            // Source counter is 7
-            7,
-            "Source counter after 110ms advance, 1st update"
+            None,
+            "Value (5) immediately after a pass should be blocked again."
         );
-        app.world_mut()
-            .insert_resource(TimeUpdateStrategy::ManualDuration(Duration::from_millis(0)));
 
-        // 12. Update: Source emits 8. Time < 100ms. Throttle blocks. Output remains 7.
+        // 6. Pass again: Advance time to pass the threshold again.
+        app.world_mut()
+            .resource_mut::<Time>()
+            .advance_by(Duration::from_millis(100));
         app.update();
+        // The source signal has now been called 6 times. The value should be 6.
         assert_eq!(
-            get_output::<i32>(app.world()),
-            // Output remains 7
-            Some(7),
-            "After 110ms advance, 2nd update (block 8)"
+            get_output(app.world()),
+            Some(6),
+            "Value (6) should pass again after another full duration."
         );
-        assert_eq!(
-            *emit_count.lock().unwrap(),
-            // Emit count remains 4
-            4,
-            "Emit count after 110ms advance, 2nd update"
-        );
-        assert_eq!(
-            *counter.lock().unwrap(),
-            // Source counter is 8
-            8,
-            "Source counter after 110ms advance, 2nd update"
-        );
-        signal.cleanup(app.world_mut());
+
+        handle.cleanup(app.world_mut());
     }
 
     #[test]
diff --git a/src/signal_map.rs b/src/signal_map.rs
index 047310a..3502033 100644
--- a/src/signal_map.rs
+++ b/src/signal_map.rs
@@ -2,8 +2,8 @@
 //! [`BTreeMap`] mutations, see [`MutableBTreeMap`] and [`SignalMapExt`].
 use super::{
     graph::{
-        LazySignal, LazySystem, SignalHandle, SignalSystem, downcast_any_clone, lazy_signal_from_system, pipe_signal,
-        poll_signal, process_signals, register_signal,
+        LazySignal, SignalHandle, SignalSystem, downcast_any_clone, lazy_signal_from_system, pipe_signal, poll_signal,
+        process_signals, register_signal,
     },
     signal::{Signal, SignalBuilder, SignalExt},
     signal_vec::{Replayable, SignalVec, VecDiff},
@@ -16,9 +16,10 @@ use bevy_ecs::prelude::*;
 use bevy_log::debug;
 use bevy_platform::{
     prelude::*,
-    sync::{Arc, RwLock, RwLockReadGuard, RwLockWriteGuard},
+    sync::{Arc, LazyLock, Mutex},
 };
-use core::{fmt, marker::PhantomData, ops::Deref};
+use core::{fmt, marker::PhantomData, ops::Deref, sync::atomic::AtomicUsize};
+use dyn_clone::{DynClone, clone_trait_object};
 
 /// Describes the mutations made to the underlying [`MutableBTreeMap`] that are piped to downstream
 /// [`SignalMap`]s.
@@ -135,6 +136,16 @@ impl<K: 'static, V: 'static> SignalMap for Box<dyn SignalMap<Key = K, Value = V>
     }
 }
 
+/// An extension trait for [`SignalMap`] types that implement [`Clone`].
+///
+/// Relevant in contexts where some function may require a [`Clone`] [`SignalMap`], but the concrete
+/// type can't be known at compile-time.
+pub trait SignalMapDynClone: SignalMap + DynClone {}
+
+clone_trait_object!(<K, V> SignalMapDynClone<Key = K, Value = V>);
+
+impl<T: SignalMap + Clone + 'static> SignalMapDynClone for T {}
+
 /// Signal graph node which applies a [`System`] directly to the "raw" [`Vec<MapDiff>`]s of its
 /// upstream, see [.for_each](SignalMapExt::for_each).
 #[derive(Clone)]
@@ -326,7 +337,11 @@ pub trait SignalMapExt: SignalMap {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// MutableBTreeMap::from([(1, 2), (3, 4)]).signal_map().map_value(|In(x)| x * 2); // outputs `SignalMap -> {1: 2, 3: 4}`
+    /// let mut world = World::new();
+    /// MutableBTreeMapBuilder::from([(1, 2), (3, 4)])
+    ///     .spawn(&mut world)
+    ///     .signal_map()
+    ///     .map_value(|In(x)| x * 2); // outputs `SignalMap -> {1: 2, 3: 4}`
     /// ```
     fn map_value<O, F, M>(self, system: F) -> MapValue<Self, O>
     where
@@ -368,7 +383,10 @@ pub trait SignalMapExt: SignalMap {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// MutableBTreeMap::from([(1, 2), (3, 4)]).signal_map()
+    /// let mut world = World::new();
+    /// MutableBTreeMapBuilder::from([(1, 2), (3, 4)])
+    ///     .spawn(&mut world)
+    ///     .signal_map()
     ///     .map_value_signal(|In(x)|
     ///         SignalBuilder::from_system(move |_: In<()>| x * 2).dedupe()
     ///     ); // outputs `SignalMap -> {1: 4, 3: 8}`
@@ -601,9 +619,14 @@ pub trait SignalMapExt: SignalMap {
     /// # Example
     ///
     /// ```
+    /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// MutableBTreeMap::from([(1, 2), (3, 4)]).signal_map().key(1); // outputs `2`
+    /// let mut world = World::new();
+    /// MutableBTreeMapBuilder::from([(1, 2), (3, 4)])
+    ///     .spawn(&mut world)
+    ///     .signal_map()
+    ///     .key(1); // outputs `2`
     /// ```
     fn key(self, key: Self::Key) -> Key<Self>
     where
@@ -661,12 +684,11 @@ pub trait SignalMapExt: SignalMap {
     /// use jonmo::prelude::*;
     ///
     /// let mut world = World::new();
-    /// let mut map = MutableBTreeMap::from([(1, 2), (3, 4)]);
+    /// let mut map = MutableBTreeMapBuilder::from([(1, 2), (3, 4)]).spawn(&mut world);
     /// let signal = map.signal_map().debug();
     /// // `signal` logs `[ Replace { entries: [ (1, 2), (3, 4) ] } ]`
-    /// map.write().insert(5, 6);
-    /// world.commands().queue(map.flush());
-    /// // `signal` logs `[ Insert { key: 5, value: 6 } ]`
+    /// map.write(&mut world).insert(5, 6);
+    /// // `signal` logs `[ Insert { key: 5, value: 6 } ]` on next update
     /// ```
     fn debug(self) -> Debug<Self>
     where
@@ -692,11 +714,20 @@ pub trait SignalMapExt: SignalMap {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
+    /// let mut world = World::new();
     /// let condition = true;
     /// let signal = if condition {
-    ///     MutableBTreeMap::from([(1, 2), (3, 4)]).signal_map().map_value(|In(x): In<i32>| x * 2).boxed() // this is a `MapValue<Source<i32, i32>>`
+    ///     MutableBTreeMapBuilder::from([(1, 2), (3, 4)])
+    ///         .spawn(&mut world)
+    ///         .signal_map()
+    ///         .map_value(|In(x): In<i32>| x * 2)
+    ///         .boxed() // this is a `MapValue<Source<i32, i32>>`
     /// } else {
-    ///     MutableBTreeMap::from([(1, 2), (3, 4)]).signal_map().map_value_signal(|In(x): In<i32>| SignalBuilder::from_system(move |_: In<()>| x * 2)).boxed() // this is a `MapValueSignal<Source<i32, i32>>`
+    ///     MutableBTreeMapBuilder::from([(1, 2), (3, 4)])
+    ///         .spawn(&mut world)
+    ///         .signal_map()
+    ///         .map_value_signal(|In(x): In<i32>| SignalBuilder::from_system(move |_: In<()>| x * 2))
+    ///         .boxed() // this is a `MapValueSignal<Source<i32, i32>>`
     /// }; // without the `.boxed()`, the compiler would not allow this
     /// ```
     fn boxed(self) -> Box<dyn SignalMap<Key = Self::Key, Value = Self::Value>>
@@ -718,12 +749,21 @@ pub trait SignalMapExt: SignalMap {
 
 impl<T: ?Sized> SignalMapExt for T where T: SignalMap {}
 
+static STALE_MUTABLE_BTREE_MAPS: LazyLock<Mutex<Vec<Entity>>> = LazyLock::new(Mutex::default);
+
+pub(crate) fn despawn_stale_mutable_btree_maps(world: &mut World) {
+    let mut queue = STALE_MUTABLE_BTREE_MAPS.lock().unwrap();
+    for entity in queue.drain(..) {
+        world.despawn(entity);
+    }
+}
+
 /// Provides immutable access to the underlying [`BTreeMap`].
-pub struct MutableBTreeMapReadGuard<'a, K, V> {
-    guard: RwLockReadGuard<'a, MutableBTreeMapState<K, V>>,
+pub struct MutableBTreeMapReadGuard<'s, K, V> {
+    guard: &'s MutableBTreeMapData<K, V>,
 }
 
-impl<'a, K, V> Deref for MutableBTreeMapReadGuard<'a, K, V> {
+impl<'s, K, V> Deref for MutableBTreeMapReadGuard<'s, K, V> {
     type Target = BTreeMap<K, V>;
 
     fn deref(&self) -> &Self::Target {
@@ -732,8 +772,16 @@ impl<'a, K, V> Deref for MutableBTreeMapReadGuard<'a, K, V> {
 }
 
 /// Provides limited mutable access to the underlying [`BTreeMap`].
-pub struct MutableBTreeMapWriteGuard<'a, K, V> {
-    guard: RwLockWriteGuard<'a, MutableBTreeMapState<K, V>>,
+pub struct MutableBTreeMapWriteGuard<'s, K, V> {
+    guard: Mut<'s, MutableBTreeMapData<K, V>>,
+}
+
+impl<'s, K, V> Deref for MutableBTreeMapWriteGuard<'s, K, V> {
+    type Target = BTreeMap<K, V>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.guard.map
+    }
 }
 
 impl<'a, K, V> MutableBTreeMapWriteGuard<'a, K, V>
@@ -795,42 +843,40 @@ where
     }
 }
 
-impl<'a, K, V> Deref for MutableBTreeMapWriteGuard<'a, K, V> {
-    type Target = BTreeMap<K, V>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.guard.map
-    }
-}
-
-struct MutableBTreeMapState<K, V> {
+/// [`Component`] that holds the actual state for a [`MutableBTreeMap`].
+#[derive(Component)]
+pub struct MutableBTreeMapData<K, V> {
     map: BTreeMap<K, V>,
     pending_diffs: Vec<MapDiff<K, V>>,
-    signal: Option<LazySignal>,
+    broadcaster: LazySignal,
 }
 
 #[derive(Component)]
 struct QueuedMapDiffs<K, V>(Vec<MapDiff<K, V>>);
 
-/// Wrapper around a [`BTreeMap`] that tracks mutations as [`MapDiff`]s and emits them on
-/// [`.flush`](MutableBTreeMap::flush), enabling diff-less constant-time reactive updates for
-/// downstream [`SignalMap`]s.
-#[derive(Clone)]
+/// Wrapper around a [`BTreeMap`] that emits mutations as [`MapDiff`]s, enabling diff-less
+/// constant-time reactive updates for downstream [`SignalMap`]s.
 pub struct MutableBTreeMap<K, V> {
-    state: Arc<RwLock<MutableBTreeMapState<K, V>>>,
+    entity: Entity,
+    references: Arc<AtomicUsize>,
+    _marker: PhantomData<fn() -> (K, V)>,
 }
 
-impl<T, K, V> From<T> for MutableBTreeMap<K, V>
-where
-    BTreeMap<K, V>: From<T>,
-{
-    fn from(values: T) -> Self {
+impl<K, V> Clone for MutableBTreeMap<K, V> {
+    fn clone(&self) -> Self {
+        self.references.fetch_add(1, core::sync::atomic::Ordering::SeqCst);
         Self {
-            state: Arc::new(RwLock::new(MutableBTreeMapState {
-                map: values.into(),
-                pending_diffs: Vec::new(),
-                signal: None,
-            })),
+            entity: self.entity,
+            references: self.references.clone(),
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<K, V> Drop for MutableBTreeMap<K, V> {
+    fn drop(&mut self) {
+        if self.references.fetch_sub(1, core::sync::atomic::Ordering::SeqCst) == 1 {
+            STALE_MUTABLE_BTREE_MAPS.lock().unwrap().push(self.entity);
         }
     }
 }
@@ -865,140 +911,99 @@ impl Replayable for MapReplayTrigger {
     }
 }
 
-impl<K, V> MutableBTreeMap<K, V> {
-    /// Constructs a new, emtpy [`MutableBTreeMap<K, V>`].
-    #[allow(clippy::new_without_default)]
-    pub fn new() -> Self {
-        Self::from(BTreeMap::new())
-    }
+fn new_mutable_btree_map_data<K, V>(map: BTreeMap<K, V>) -> (MutableBTreeMapData<K, V>, LazyEntity)
+where
+    K: Ord + Clone + SSs,
+    V: Clone + SSs,
+{
+    let data_entity = LazyEntity::new();
+    let broadcaster = LazySignal::new(clone!((data_entity) move |world: &mut World| {
+        let source_system = move |_: In<()>, mut mutable_btree_map_datas: Query<&mut MutableBTreeMapData<K, V>>| {
+            let mut data = mutable_btree_map_datas.get_mut(*data_entity).unwrap();
+            if data.pending_diffs.is_empty() {
+                None
+            } else {
+                Some(core::mem::take(&mut data.pending_diffs))
+            }
+        };
 
-    /// Locks this [`MutableBTreeMap`] with shared read access, blocking the current thread until it
-    /// can be acquired, see [`RwLock::read`].
-    pub fn read(&self) -> MutableBTreeMapReadGuard<'_, K, V> {
-        MutableBTreeMapReadGuard {
-            guard: self.state.read().unwrap(),
-        }
-    }
+        register_signal::<(), Vec<MapDiff<K, V>>, _, _, _>(world, source_system)
+    }));
+    (
+        MutableBTreeMapData {
+            map,
+            pending_diffs: Vec::new(),
+            broadcaster,
+        },
+        data_entity,
+    )
+}
 
-    /// Locks this [`MutableBTreeMap`] with exclusive write access, blocking the current thread
-    /// until it can be acquired, see [`RwLock::write`].
-    pub fn write(&self) -> MutableBTreeMapWriteGuard<'_, K, V> {
-        MutableBTreeMapWriteGuard {
-            guard: self.state.write().unwrap(),
+impl<K, V> MutableBTreeMap<K, V> {
+    /// Provides read-only access to the underlying [`BTreeMap`] via either a `&World` or a
+    /// `&Query<MutableBTreeMapData<K, V>>`.
+    pub fn read<'s>(
+        &self,
+        mutable_btree_map_data_reader: impl ReadMutableBTreeMapData<'s, K, V>,
+    ) -> MutableBTreeMapReadGuard<'s, K, V>
+    where
+        K: SSs,
+        V: SSs,
+    {
+        MutableBTreeMapReadGuard {
+            guard: mutable_btree_map_data_reader.read(self.entity),
         }
     }
 
-    fn get_or_create_broadcaster_signal(&self) -> LazySignal
+    /// Provides write access to the underlying [`BTreeMap`] via either a `&mut World` or a
+    /// `&mut Query<&mut MutableBTreeMapData<K, V>>`.
+    pub fn write<'w>(
+        &self,
+        mutable_btree_map_data_writer: impl WriteMutableBTreeMapData<'w, K, V>,
+    ) -> MutableBTreeMapWriteGuard<'w, K, V>
     where
-        K: Clone + SSs,
-        V: Clone + SSs,
+        K: SSs,
+        V: SSs,
     {
-        let mut state = self.state.write().unwrap();
-
-        // If the signal already exists, just clone and return it.
-        if let Some(lazy_signal) = &state.signal {
-            return lazy_signal.clone();
+        MutableBTreeMapWriteGuard {
+            guard: mutable_btree_map_data_writer.write(self.entity),
         }
-
-        // Otherwise, create the broadcaster signal for the first time.
-        let broadcaster_lazy_signal = LazySignal::new(move |world: &mut World| {
-            let self_entity = LazyEntity::new();
-
-            // This is the system for the one-and-only broadcaster. It just drains diffs that
-            // `flush` has put into its component.
-            let source_system_logic = clone!((self_entity) move |_: In<()>, world: &mut World| {
-                if let Some(mut diffs) = world.get_mut::<QueuedMapDiffs<K, V>>(self_entity.get()) {
-                    if diffs.0.is_empty() {
-                        None
-                    } else {
-                        Some(diffs.0.drain(..).collect())
-                    }
-                } else {
-                    None
-                }
-            });
-            let signal_system = register_signal::<(), Vec<MapDiff<K, V>>, _, _, _>(world, source_system_logic);
-            self_entity.set(*signal_system);
-
-            // The broadcaster itself does not have an initial state to replay. It just needs
-            // the component to receive flushed diffs.
-            world.entity_mut(*signal_system).insert(QueuedMapDiffs::<K, V>(vec![]));
-            signal_system
-        });
-
-        // Store it for future calls.
-        state.signal = Some(broadcaster_lazy_signal.clone());
-        broadcaster_lazy_signal
     }
 
-    /// Returns a [`Source`] signal from this [`MutableBTreeMap`], always returning clones of the
-    /// same underlying [`Signal`]; such [`SignalMap`]s only emit incremental updates so clones will
-    /// not re-emit initial states.
+    /// Returns a [`Source`] signal from this [`MutableBTreeMap`].
     pub fn signal_map(&self) -> Source<K, V>
     where
         K: Clone + Ord + SSs,
         V: Clone + SSs,
     {
-        let broadcaster_signal = self.get_or_create_broadcaster_signal();
-        let replay_lazy_signal = LazySignal::new(clone!((self.state => state) move | world: & mut World | {
-            let self_entity = LazyEntity::new();
-            let broadcaster_system = broadcaster_signal.register(world);
-
-            let replay_system_logic =
-                clone!(
-                    (self_entity) move | In(upstream_diffs): In<Vec<MapDiff<K, V>>>,
-                    world: & mut World,
-                    mut has_run: Local < bool >| {
-                        if !*has_run {
-                            // First run: This is triggered manually by the `MapReplayTrigger`.
-                            // It processes the initial state queued on its own entity and ignores upstream.
-                            *has_run = true;
-                            let initial_diffs =
-                                world
-                                    .get_entity_mut(self_entity.get())
-                                    .ok()
-                                    .and_then(|mut entity| entity.take::<QueuedMapDiffs<K, V>>())
-                                    .map(|queued| queued.0)
-                                    .unwrap_or_default();
-                            if initial_diffs.is_empty() {
-                                None
-                            } else {
-                                Some(initial_diffs)
-                            }
-                        } else {
-                            // Subsequent runs: Triggered by the broadcaster. Process upstream diffs.
-                            if upstream_diffs.is_empty() {
-                                None
-                            } else {
-                                Some(upstream_diffs)
-                            }
-                        }
+        let replay_lazy_signal = LazySignal::new(clone!((self => self_) move |world: &mut World| {
+            let broadcaster_system = world.get::<MutableBTreeMapData<K, V>>(self_.entity).unwrap().broadcaster.clone().register(world);
+
+            let replay_system_logic = clone!((self_) move |In(upstream_diffs): In<Vec<MapDiff<K, V>>>, world: &mut World, mut has_run: Local<bool>| {
+                if !*has_run {
+                    *has_run = true;
+                    let initial_map = self_.read(&*world);
+                    if !initial_map.is_empty() {
+                        Some(vec![MapDiff::Replace { entries: initial_map.iter().map(|(k, v)| (k.clone(), v.clone())).collect() }])
+                    } else {
+                        None
                     }
-                );
+                } else if upstream_diffs.is_empty() { None } else { Some(upstream_diffs) }
+            });
 
-            // 1. Register the replay system.
             let replay_signal = register_signal::<_, Vec<MapDiff<K, V>>, _, _, _>(world, replay_system_logic);
-            self_entity.set(*replay_signal);
 
-            // The trigger now unconditionally pokes the replay system with an empty input.
-            // The replay system's own logic will handle whether it's the first run or not.
             let trigger = Box::new(move |world: &mut World| {
                 process_signals(world, [replay_signal], Box::new(Vec::<MapDiff<K, V>>::new()));
             });
 
-            // 2. Queue the initial state for this new subscriber.
-            let initial_map: BTreeMap<K, V> = state.read().unwrap().map.clone();
-            let initial_diffs = if !initial_map.is_empty() {
-                vec![MapDiff::Replace { entries: initial_map.into_iter().collect() }]
-            } else {
-                vec![]
-            };
-            world.entity_mut(*replay_signal).insert((QueuedMapDiffs(initial_diffs), MapReplayTrigger(trigger)));
+            let mut replay_entity = world.entity_mut(*replay_signal);
+            replay_entity.insert(MapReplayTrigger(trigger));
 
-            // 3. Pipe the broadcaster to the new replay node.
             pipe_signal(world, broadcaster_system, replay_signal);
             replay_signal
         }));
+
         Source {
             signal: replay_lazy_signal,
             _marker: PhantomData,
@@ -1114,46 +1119,157 @@ impl<K, V> MutableBTreeMap<K, V> {
             _marker: PhantomData,
         }
     }
+}
 
-    /// Emits any pending [`MapDiff`]s to downstream [`SignalMap`]s.
-    pub fn flush_into_world(&self, world: &mut World)
-    where
-        K: SSs,
-        V: SSs,
-    {
-        let mut state = self.state.write().unwrap();
-        if state.pending_diffs.is_empty() {
-            return;
+impl<K, V> From<&mut World> for MutableBTreeMap<K, V>
+where
+    K: Ord + Clone + SSs,
+    V: Clone + SSs,
+{
+    fn from(world: &mut World) -> Self {
+        let (data, data_entity) = new_mutable_btree_map_data::<K, V>(BTreeMap::new());
+        let entity = world.spawn(data).id();
+        data_entity.set(entity);
+        Self {
+            entity,
+            references: Arc::new(AtomicUsize::new(1)),
+            _marker: PhantomData,
         }
-        let signal = if let Some(lazy_signal) = &state.signal
-            && let LazySystem::Registered(signal_system) = *lazy_signal.inner.system.read().unwrap()
-        {
-            signal_system
-        } else {
-            return;
-        };
-        if let Ok(mut entity) = world.get_entity_mut(*signal)
-            && let Some(mut queued_diffs) = entity.get_mut::<QueuedMapDiffs<K, V>>()
-        {
-            queued_diffs.0.append(&mut state.pending_diffs);
+    }
+}
+
+impl<K, V> FromWorld for MutableBTreeMap<K, V>
+where
+    K: Ord + Clone + SSs,
+    V: Clone + SSs,
+{
+    fn from_world(world: &mut World) -> Self {
+        world.into()
+    }
+}
+
+/// Builder for constructing a [`MutableBTreeMap`] with initial values, e.g.
+/// `MutableBTreeMapBuilder::from([(0, 1), (1, 2)]).spawn(&mut World)`.
+pub struct MutableBTreeMapBuilder<K, V>(BTreeMap<K, V>);
+
+impl<K, V, A> From<A> for MutableBTreeMapBuilder<K, V>
+where
+    BTreeMap<K, V>: From<A>,
+{
+    fn from(value: A) -> Self {
+        Self(value.into())
+    }
+}
+
+impl<K, V> MutableBTreeMapBuilder<K, V>
+where
+    K: Ord + Clone + SSs,
+    V: Clone + SSs,
+{
+    /// Spawns a [`MutableBTreeMap`] using a `&mut World`.
+    pub fn spawn(self, world: &mut World) -> MutableBTreeMap<K, V> {
+        let (data, data_entity) = new_mutable_btree_map_data::<K, V>(self.0);
+        let entity = world.spawn(data).id();
+        data_entity.set(entity);
+        MutableBTreeMap {
+            entity,
+            references: Arc::new(AtomicUsize::new(1)),
+            _marker: PhantomData,
         }
     }
 
-    /// Returns an `impl Command` that can be passed to [`Commands::queue`] to flush this
-    /// [`MutableBTreeMap`]'s pending [`MapDiff`]s, see
-    /// [`.flush_into_world`](Self::flush_into_world).
-    pub fn flush(&self) -> impl Command
-    where
-        K: Clone + SSs,
-        V: Clone + SSs,
-    {
-        let self_ = self.clone();
-        move |world: &mut World| self_.flush_into_world(world)
+    /// Spawns a [`MutableBTreeMap`] using a `&mut Commands`.
+    pub fn spawnc(self, commands: &mut Commands) -> MutableBTreeMap<K, V> {
+        let (data, data_entity) = new_mutable_btree_map_data::<K, V>(self.0);
+        let entity = commands.spawn(data).id();
+        data_entity.set(entity);
+        MutableBTreeMap {
+            entity,
+            references: Arc::new(AtomicUsize::new(1)),
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<K, V> From<&mut Commands<'_, '_>> for MutableBTreeMap<K, V>
+where
+    K: Ord + Clone + SSs,
+    V: Clone + SSs,
+{
+    fn from(commands: &mut Commands) -> Self {
+        let (data, data_entity) = new_mutable_btree_map_data::<K, V>(BTreeMap::new());
+        let entity = commands.spawn(data).id();
+        data_entity.set(entity);
+        Self {
+            entity,
+            references: Arc::new(AtomicUsize::new(1)),
+            _marker: PhantomData,
+        }
+    }
+}
+
+/// Specifies read accessors for [`MutableBTreeMap`]s.
+pub trait ReadMutableBTreeMapData<'s, K, V>
+where
+    K: Send + Sync,
+    V: Send + Sync,
+{
+    #[allow(missing_docs)]
+    fn read(self, entity: Entity) -> &'s MutableBTreeMapData<K, V>;
+}
+
+impl<'s, K, V> ReadMutableBTreeMapData<'s, K, V> for &'s Query<'_, 's, &MutableBTreeMapData<K, V>>
+where
+    K: SSs,
+    V: SSs,
+{
+    fn read(self, entity: Entity) -> &'s MutableBTreeMapData<K, V> {
+        self.get(entity).unwrap()
+    }
+}
+
+impl<'s, K, V> ReadMutableBTreeMapData<'s, K, V> for &'s World
+where
+    K: SSs,
+    V: SSs,
+{
+    fn read(self, entity: Entity) -> &'s MutableBTreeMapData<K, V> {
+        self.get(entity).unwrap()
+    }
+}
+
+/// Specifies write accessors for [`MutableBTreeMap`]s.
+pub trait WriteMutableBTreeMapData<'w, K, V>
+where
+    K: Send + Sync,
+    V: Send + Sync,
+{
+    #[allow(missing_docs)]
+    fn write(self, entity: Entity) -> Mut<'w, MutableBTreeMapData<K, V>>;
+}
+
+impl<'a, 'w, 's, K, V> WriteMutableBTreeMapData<'a, K, V> for &'a mut Query<'w, 's, &mut MutableBTreeMapData<K, V>>
+where
+    K: SSs,
+    V: SSs,
+{
+    fn write(self, entity: Entity) -> Mut<'a, MutableBTreeMapData<K, V>> {
+        self.get_mut(entity).unwrap()
+    }
+}
+
+impl<'w, K, V> WriteMutableBTreeMapData<'w, K, V> for &'w mut World
+where
+    K: SSs,
+    V: SSs,
+{
+    fn write(self, entity: Entity) -> Mut<'w, MutableBTreeMapData<K, V>> {
+        self.get_mut(entity).unwrap()
     }
 }
 
 #[cfg(test)]
-mod tests {
+pub(crate) mod tests {
     use super::*;
     use crate::{JonmoPlugin, signal_vec::SignalVecExt};
     use bevy::prelude::*;
@@ -1227,318 +1343,328 @@ mod tests {
         }
     }
 
+    pub(crate) fn cleanup(vecs_too: bool) {
+        STALE_MUTABLE_BTREE_MAPS.lock().unwrap().clear();
+        if vecs_too {
+            crate::signal_vec::tests::cleanup(false);
+        }
+    }
+
     #[test]
     fn test_for_each() {
-        let mut app = create_test_app();
-
-        // The output of our `for_each` system will be the full, reconstructed BTreeMap.
-        app.init_resource::<SignalOutput<BTreeMap<u32, String>>>();
-        let source_map = MutableBTreeMap::from([(1, "one".to_string()), (2, "two".to_string())]);
-
-        // This system reconstructs the state of the map by applying the diffs it
-        // receives. It then outputs the complete, current state of the map. This allows
-        // us to verify that `for_each` is receiving the diffs correctly.
-        let reconstructor_system = |In(diffs): In<Vec<MapDiff<u32, String>>>,
-                                    mut state: Local<BTreeMap<u32, String>>| {
-            for diff in diffs {
-                match diff {
-                    MapDiff::Replace { entries } => {
-                        *state = entries.into_iter().collect();
-                    }
-                    MapDiff::Insert { key, value } | MapDiff::Update { key, value } => {
-                        state.insert(key, value);
-                    }
-                    MapDiff::Remove { key } => {
-                        state.remove(&key);
-                    }
-                    MapDiff::Clear => {
-                        state.clear();
-                    }
-                }
-            }
-
-            // Output the current reconstructed state
-            state.clone()
-        };
-        let handle = source_map
-            .signal_map()
-            .for_each(reconstructor_system)
-            .map(capture_output::<BTreeMap<u32, String>>)
-            .register(app.world_mut());
-
-        // Test 1: Initial State. The initial `Replace` diff should be received and
-        // processed.
-        app.update();
-        let expected_initial_state: BTreeMap<_, _> =
-            [(1, "one".to_string()), (2, "two".to_string())].into_iter().collect();
-        assert_eq!(
-            get_output::<BTreeMap<u32, String>>(app.world_mut()),
-            Some(expected_initial_state.clone()),
-            "Initial state was not reconstructed correctly"
-        );
-
-        // Test 2: Batched Mutations. We'll perform multiple operations before flushing to
-        // test batch processing.
         {
-            let mut writer = source_map.write();
-
-            // Insert
-            writer.insert(3, "three".to_string());
-
-            // Update
-            writer.insert(1, "one_v2".to_string());
+            let mut app = create_test_app();
+
+            // The output of our `for_each` system will be the full, reconstructed BTreeMap.
+            app.init_resource::<SignalOutput<BTreeMap<u32, String>>>();
+            let source_map =
+                (MutableBTreeMapBuilder::from([(1, "one".to_string()), (2, "two".to_string())])).spawn(app.world_mut());
+
+            // This system reconstructs the state of the map by applying the diffs it
+            // receives. It then outputs the complete, current state of the map. This allows
+            // us to verify that `for_each` is receiving the diffs correctly.
+            let reconstructor_system =
+                |In(diffs): In<Vec<MapDiff<u32, String>>>, mut state: Local<BTreeMap<u32, String>>| {
+                    for diff in diffs {
+                        match diff {
+                            MapDiff::Replace { entries } => {
+                                *state = entries.into_iter().collect();
+                            }
+                            MapDiff::Insert { key, value } | MapDiff::Update { key, value } => {
+                                state.insert(key, value);
+                            }
+                            MapDiff::Remove { key } => {
+                                state.remove(&key);
+                            }
+                            MapDiff::Clear => {
+                                state.clear();
+                            }
+                        }
+                    }
 
-            // Remove
-            writer.remove(&2);
+                    // Output the current reconstructed state
+                    state.clone()
+                };
+            let handle = source_map
+                .signal_map()
+                .for_each(reconstructor_system)
+                .map(capture_output::<BTreeMap<u32, String>>)
+                .register(app.world_mut());
+
+            // Test 1: Initial State. The initial `Replace` diff should be received and
+            // processed.
+            app.update();
+            let expected_initial_state: BTreeMap<_, _> =
+                [(1, "one".to_string()), (2, "two".to_string())].into_iter().collect();
+            assert_eq!(
+                get_output::<BTreeMap<u32, String>>(app.world_mut()),
+                Some(expected_initial_state.clone()),
+                "Initial state was not reconstructed correctly"
+            );
+
+            // Test 2: Batched Mutations. We'll perform multiple operations before the next
+            // update to test batch processing.
+            {
+                let mut writer = source_map.write(app.world_mut());
+
+                // Insert
+                writer.insert(3, "three".to_string());
+
+                // Update
+                writer.insert(1, "one_v2".to_string());
+
+                // Remove
+                writer.remove(&2);
+            }
+            app.update();
+            let expected_batched_state: BTreeMap<_, _> = [(1, "one_v2".to_string()), (3, "three".to_string())]
+                .into_iter()
+                .collect();
+            assert_eq!(
+                get_output::<BTreeMap<u32, String>>(app.world_mut()),
+                Some(expected_batched_state.clone()),
+                "State after batched mutations was not reconstructed correctly"
+            );
+
+            // Test 3: Clear. The `Clear` diff should result in an empty map.
+            source_map.write(app.world_mut()).clear();
+            app.update();
+            let expected_cleared_state: BTreeMap<u32, String> = BTreeMap::new();
+            assert_eq!(
+                get_output::<BTreeMap<u32, String>>(app.world_mut()),
+                Some(expected_cleared_state.clone()),
+                "State after Clear was not reconstructed correctly"
+            );
+            handle.cleanup(app.world_mut());
         }
-        source_map.flush_into_world(app.world_mut());
-        app.update();
-        let expected_batched_state: BTreeMap<_, _> = [(1, "one_v2".to_string()), (3, "three".to_string())]
-            .into_iter()
-            .collect();
-        assert_eq!(
-            get_output::<BTreeMap<u32, String>>(app.world_mut()),
-            Some(expected_batched_state.clone()),
-            "State after batched mutations was not reconstructed correctly"
-        );
-
-        // Test 3: Clear. The `Clear` diff should result in an empty map.
-        source_map.write().clear();
-        source_map.flush_into_world(app.world_mut());
-        app.update();
-        let expected_cleared_state: BTreeMap<u32, String> = BTreeMap::new();
-        assert_eq!(
-            get_output::<BTreeMap<u32, String>>(app.world_mut()),
-            Some(expected_cleared_state.clone()),
-            "State after Clear was not reconstructed correctly"
-        );
-        handle.cleanup(app.world_mut());
+
+        cleanup(true);
     }
 
     #[test]
     fn test_map_value() {
-        let mut app = create_test_app();
-
-        // The output map will have keys of `u32` and values of `String`.
-        app.init_resource::<SignalMapOutput<u32, String>>();
-
-        // The source map contains integer values.
-        let source_map = MutableBTreeMap::from([(1, 10), (2, 20)]);
-
-        // The mapping function transforms an i32 value into a String.
-        let mapping_system = |In(val): In<i32>| format!("Val:{val}");
-
-        // Apply `map_value` to create the derived signal.
-        let mapped_signal = source_map.signal_map().map_value(mapping_system);
-        let handle = mapped_signal
-            .for_each(capture_map_output::<u32, String>)
-            .register(app.world_mut());
-
-        // Test 1: Initial State (Replace). The first update should replay the initial
-        // state with mapped values.
-        app.update();
-        let diffs = get_and_clear_map_output::<u32, String>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Initial state should produce one Replace diff");
-        assert_eq!(
-            diffs[0],
-            MapDiff::Replace {
-                entries: vec![(1, "Val:10".to_string()), (2, "Val:20".to_string())]
-            },
-            "Initial Replace diff has incorrect mapped values"
-        );
-
-        // Test 2: Insert. A new entry in the source should result in an Insert diff with
-        // a mapped value.
-        source_map.write().insert(3, 30);
-        source_map.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_map_output::<u32, String>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Insert should produce one diff");
-        assert_eq!(
-            diffs[0],
-            MapDiff::Insert {
-                key: 3,
-                value: "Val:30".to_string(),
-            },
-            "Insert diff has incorrect mapped value"
-        );
-
-        // Test 3: Update. Updating an existing entry should result in an Update diff with
-        // a mapped value. `insert` on existing key is an update
-        source_map.write().insert(1, 15);
-        source_map.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_map_output::<u32, String>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Update should produce one diff");
-        assert_eq!(
-            diffs[0],
-            MapDiff::Update {
-                key: 1,
-                value: "Val:15".to_string(),
-            },
-            "Update diff has incorrect mapped value"
-        );
-
-        // Test 4: Remove. Removing an entry should result in a Remove diff, which has no
-        // value to map.
-        source_map.write().remove(&2);
-        source_map.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_map_output::<u32, String>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Remove should produce one diff");
-        assert_eq!(
-            diffs[0],
-            MapDiff::Remove { key: 2 },
-            "Remove diff was not propagated correctly"
-        );
-
-        // Test 5: Clear. Clearing the source map should result in a Clear diff.
-        source_map.write().clear();
-        source_map.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_map_output::<u32, String>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Clear should produce one diff");
-        assert_eq!(diffs[0], MapDiff::Clear, "Clear diff was not propagated correctly");
-        handle.cleanup(app.world_mut());
+        {
+            let mut app = create_test_app();
+
+            // The output map will have keys of `u32` and values of `String`.
+            app.init_resource::<SignalMapOutput<u32, String>>();
+
+            // The source map contains integer values.
+            let source_map = (MutableBTreeMapBuilder::from([(1, 10), (2, 20)])).spawn(app.world_mut());
+
+            // The mapping function transforms an i32 value into a String.
+            let mapping_system = |In(val): In<i32>| format!("Val:{val}");
+
+            // Apply `map_value` to create the derived signal.
+            let mapped_signal = source_map.signal_map().map_value(mapping_system);
+            let handle = mapped_signal
+                .for_each(capture_map_output::<u32, String>)
+                .register(app.world_mut());
+
+            // Test 1: Initial State (Replace). The first update should replay the initial
+            // state with mapped values.
+            app.update();
+            let diffs = get_and_clear_map_output::<u32, String>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Initial state should produce one Replace diff");
+            assert_eq!(
+                diffs[0],
+                MapDiff::Replace {
+                    entries: vec![(1, "Val:10".to_string()), (2, "Val:20".to_string())]
+                },
+                "Initial Replace diff has incorrect mapped values"
+            );
+
+            // Test 2: Insert. A new entry in the source should result in an Insert diff with
+            // a mapped value.
+            source_map.write(app.world_mut()).insert(3, 30);
+            app.update();
+            let diffs = get_and_clear_map_output::<u32, String>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Insert should produce one diff");
+            assert_eq!(
+                diffs[0],
+                MapDiff::Insert {
+                    key: 3,
+                    value: "Val:30".to_string(),
+                },
+                "Insert diff has incorrect mapped value"
+            );
+
+            // Test 3: Update. Updating an existing entry should result in an Update diff with
+            // a mapped value. `insert` on existing key is an update
+            source_map.write(app.world_mut()).insert(1, 15);
+            app.update();
+            let diffs = get_and_clear_map_output::<u32, String>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Update should produce one diff");
+            assert_eq!(
+                diffs[0],
+                MapDiff::Update {
+                    key: 1,
+                    value: "Val:15".to_string(),
+                },
+                "Update diff has incorrect mapped value"
+            );
+
+            // Test 4: Remove. Removing an entry should result in a Remove diff, which has no
+            // value to map.
+            source_map.write(app.world_mut()).remove(&2);
+            app.update();
+            let diffs = get_and_clear_map_output::<u32, String>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Remove should produce one diff");
+            assert_eq!(
+                diffs[0],
+                MapDiff::Remove { key: 2 },
+                "Remove diff was not propagated correctly"
+            );
+
+            // Test 5: Clear. Clearing the source map should result in a Clear diff.
+            source_map.write(app.world_mut()).clear();
+            app.update();
+            let diffs = get_and_clear_map_output::<u32, String>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Clear should produce one diff");
+            assert_eq!(diffs[0], MapDiff::Clear, "Clear diff was not propagated correctly");
+            handle.cleanup(app.world_mut());
+        }
+
+        cleanup(true);
     }
 
     #[test]
     fn test_map_value_signal() {
-        let mut app = create_test_app();
-
-        // The output map will have keys of `u32` and values of `Name` components.
-        app.init_resource::<SignalMapOutput<u32, Name>>();
-
-        // Setup: Create entities with `Name` components that our signals will track.
-        let entity_a = app.world_mut().spawn(Name::new("Alice")).id();
-        let entity_b = app.world_mut().spawn(Name::new("Bob")).id();
-
-        // The source map contains entities. The goal is to create a derived map that
-        // contains the _names_ of these entities.
-        let entity_map = MutableBTreeMap::from([(1, entity_a), (2, entity_b)]);
-
-        // This "factory" system takes an entity and creates a signal that tracks its
-        // `Name`.
-        let factory_system = |In(entity): In<Entity>| SignalBuilder::from_component::<Name>(entity).dedupe();
-
-        // Apply `map_value_signal` to transform the SignalMap<u32, Entity> into a
-        // SignalMap<u32, Name>.
-        let name_map_signal = entity_map.signal_map().map_value_signal(factory_system);
-        let handle = name_map_signal
-            .for_each(capture_map_output::<u32, Name>)
-            .register(app.world_mut());
-
-        // Test 1: Initial State. The first update should replay the initial state of the
-        // map.
-        app.update();
-        let diffs = get_and_clear_map_output::<u32, Name>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Initial state should produce one Replace diff");
-        assert_eq!(
-            diffs[0],
-            MapDiff::Replace {
-                entries: vec![(1, Name::new("Alice")), (2, Name::new("Bob"))]
-            },
-            "Initial state is incorrect"
-        );
-
-        // Test 2: Inner Signal Update. Change a component on a tracked entity. This
-        // should trigger an Update diff.
-        *app.world_mut().get_mut::<Name>(entity_a).unwrap() = Name::new("Alicia");
-        app.update();
-        let diffs = get_and_clear_map_output::<u32, Name>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Name change should produce one Update diff");
-        assert_eq!(
-            diffs[0],
-            MapDiff::Update {
-                key: 1,
-                value: Name::new("Alicia"),
-            },
-            "Update diff is incorrect"
-        );
-
-        // Test 3: No change should produce no diff.
-        app.update();
-        let diffs = get_and_clear_map_output::<u32, Name>(app.world_mut());
-        assert!(diffs.is_empty(), "No change should produce no diffs");
-
-        // Test 4: Source Map Insertion. Add a new entity to the source map. This should
-        // trigger an Insert diff.
-        let entity_c = app.world_mut().spawn(Name::new("Charlie")).id();
-        entity_map.write().insert(3, entity_c);
-        entity_map.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_map_output::<u32, Name>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Insert should produce one Insert diff");
-        assert_eq!(
-            diffs[0],
-            MapDiff::Insert {
-                key: 3,
-                value: Name::new("Charlie"),
-            },
-            "Insert diff is incorrect"
-        );
-
-        // Test 5: Source Map Removal. Remove an entity from the source map. This should
-        // trigger a Remove diff.
-        entity_map.write().remove(&2);
-        entity_map.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_map_output::<u32, Name>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Remove should produce one Remove diff");
-        assert_eq!(diffs[0], MapDiff::Remove { key: 2 }, "Remove diff is incorrect");
-
-        // Test 6: Source Map Update (switching the underlying signal). Update a key to
-        // point to a new entity. This must tear down the old signal and create a new one,
-        // resulting in an Update diff with the new value.
-        let entity_d = app.world_mut().spawn(Name::new("David")).id();
-
-        // `insert` acts as update here.
-        entity_map.write().insert(1, entity_d);
-        entity_map.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_map_output::<u32, Name>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Source map update should produce one Update diff");
-        assert_eq!(
-            diffs[0],
-            MapDiff::Update {
-                key: 1,
-                value: Name::new("David"),
-            },
-            "Update-to-new-entity diff is incorrect"
-        );
-
-        // Verify that the old signal (for entity_a) is no longer tracked.
-        *app.world_mut().get_mut::<Name>(entity_a).unwrap() = Name::new("Alicia-v2");
-        app.update();
-        let diffs = get_and_clear_map_output::<u32, Name>(app.world_mut());
-        assert!(
-            diffs.is_empty(),
-            "Update on old, replaced entity should not produce a diff"
-        );
-
-        // Verify that the new signal (for entity_d) is now being tracked.
-        *app.world_mut().get_mut::<Name>(entity_d).unwrap() = Name::new("Dave");
-        app.update();
-        let diffs = get_and_clear_map_output::<u32, Name>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Update on new entity should produce a diff");
-        assert_eq!(
-            diffs[0],
-            MapDiff::Update {
-                key: 1,
-                value: Name::new("Dave"),
-            },
-            "Update on new entity is incorrect"
-        );
-
-        // Test 7: Source Map Clear. Clear the source map. This should trigger a Clear
-        // diff.
-        entity_map.write().clear();
-        entity_map.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_map_output::<u32, Name>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Clear should produce one Clear diff");
-        assert_eq!(diffs[0], MapDiff::Clear, "Clear diff is incorrect");
-        handle.cleanup(app.world_mut());
+        {
+            let mut app = create_test_app();
+
+            // The output map will have keys of `u32` and values of `Name` components.
+            app.init_resource::<SignalMapOutput<u32, Name>>();
+
+            // Setup: Create entities with `Name` components that our signals will track.
+            let entity_a = app.world_mut().spawn(Name::new("Alice")).id();
+            let entity_b = app.world_mut().spawn(Name::new("Bob")).id();
+
+            // The source map contains entities. The goal is to create a derived map that
+            // contains the _names_ of these entities.
+            let entity_map = (MutableBTreeMapBuilder::from([(1, entity_a), (2, entity_b)])).spawn(app.world_mut());
+
+            // This "factory" system takes an entity and creates a signal that tracks its
+            // `Name`.
+            let factory_system = |In(entity): In<Entity>| SignalBuilder::from_component::<Name>(entity).dedupe();
+
+            // Apply `map_value_signal` to transform the SignalMap<u32, Entity> into a
+            // SignalMap<u32, Name>.
+            let name_map_signal = entity_map.signal_map().map_value_signal(factory_system);
+            let handle = name_map_signal
+                .for_each(capture_map_output::<u32, Name>)
+                .register(app.world_mut());
+
+            // Test 1: Initial State. The first update should replay the initial state of the
+            // map.
+            app.update();
+            let diffs = get_and_clear_map_output::<u32, Name>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Initial state should produce one Replace diff");
+            assert_eq!(
+                diffs[0],
+                MapDiff::Replace {
+                    entries: vec![(1, Name::new("Alice")), (2, Name::new("Bob"))]
+                },
+                "Initial state is incorrect"
+            );
+
+            // Test 2: Inner Signal Update. Change a component on a tracked entity. This
+            // should trigger an Update diff.
+            *app.world_mut().get_mut::<Name>(entity_a).unwrap() = Name::new("Alicia");
+            app.update();
+            let diffs = get_and_clear_map_output::<u32, Name>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Name change should produce one Update diff");
+            assert_eq!(
+                diffs[0],
+                MapDiff::Update {
+                    key: 1,
+                    value: Name::new("Alicia"),
+                },
+                "Update diff is incorrect"
+            );
+
+            // Test 3: No change should produce no diff.
+            app.update();
+            let diffs = get_and_clear_map_output::<u32, Name>(app.world_mut());
+            assert!(diffs.is_empty(), "No change should produce no diffs");
+
+            // Test 4: Source Map Insertion. Add a new entity to the source map. This should
+            // trigger an Insert diff.
+            let entity_c = app.world_mut().spawn(Name::new("Charlie")).id();
+            entity_map.write(app.world_mut()).insert(3, entity_c);
+            app.update();
+            let diffs = get_and_clear_map_output::<u32, Name>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Insert should produce one Insert diff");
+            assert_eq!(
+                diffs[0],
+                MapDiff::Insert {
+                    key: 3,
+                    value: Name::new("Charlie"),
+                },
+                "Insert diff is incorrect"
+            );
+
+            // Test 5: Source Map Removal. Remove an entity from the source map. This should
+            // trigger a Remove diff.
+            entity_map.write(app.world_mut()).remove(&2);
+            app.update();
+            let diffs = get_and_clear_map_output::<u32, Name>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Remove should produce one Remove diff");
+            assert_eq!(diffs[0], MapDiff::Remove { key: 2 }, "Remove diff is incorrect");
+
+            // Test 6: Source Map Update (switching the underlying signal). Update a key to
+            // point to a new entity. This must tear down the old signal and create a new one,
+            // resulting in an Update diff with the new value.
+            let entity_d = app.world_mut().spawn(Name::new("David")).id();
+
+            // `insert` acts as update here.
+            entity_map.write(app.world_mut()).insert(1, entity_d);
+            app.update();
+            let diffs = get_and_clear_map_output::<u32, Name>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Source map update should produce one Update diff");
+            assert_eq!(
+                diffs[0],
+                MapDiff::Update {
+                    key: 1,
+                    value: Name::new("David"),
+                },
+                "Update-to-new-entity diff is incorrect"
+            );
+
+            // Verify that the old signal (for entity_a) is no longer tracked.
+            *app.world_mut().get_mut::<Name>(entity_a).unwrap() = Name::new("Alicia-v2");
+            app.update();
+            let diffs = get_and_clear_map_output::<u32, Name>(app.world_mut());
+            assert!(
+                diffs.is_empty(),
+                "Update on old, replaced entity should not produce a diff"
+            );
+
+            // Verify that the new signal (for entity_d) is now being tracked.
+            *app.world_mut().get_mut::<Name>(entity_d).unwrap() = Name::new("Dave");
+            app.update();
+            let diffs = get_and_clear_map_output::<u32, Name>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Update on new entity should produce a diff");
+            assert_eq!(
+                diffs[0],
+                MapDiff::Update {
+                    key: 1,
+                    value: Name::new("Dave"),
+                },
+                "Update on new entity is incorrect"
+            );
+
+            // Test 7: Source Map Clear. Clear the source map. This should trigger a Clear
+            // diff.
+            entity_map.write(app.world_mut()).clear();
+            app.update();
+            let diffs = get_and_clear_map_output::<u32, Name>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Clear should produce one Clear diff");
+            assert_eq!(diffs[0], MapDiff::Clear, "Clear diff is incorrect");
+            handle.cleanup(app.world_mut());
+        }
+
+        cleanup(true);
     }
 
     // Helper resource to capture the output from a standard Signal for assertions.
@@ -1570,92 +1696,96 @@ mod tests {
 
     #[test]
     fn test_key() {
-        let mut app = create_test_app();
-
-        // The output is a Signal<Option`<String>`>.
-        app.init_resource::<SignalOutput<Option<String>>>();
-        let source_map = MutableBTreeMap::from([(1, "one".to_string()), (2, "two".to_string())]);
-
-        // We will specifically track the value associated with key `2`.
-        let key_to_track = 2;
-        let key_signal = source_map.signal_map().key(key_to_track);
-        let handle = key_signal
-            .map(capture_output::<Option<String>>)
-            .register(app.world_mut());
-
-        // Test 1: Initial State (Key is Present). The first update should emit the
-        // initial value for the key.
-        app.update();
-        assert_eq!(
-            get_output::<Option<String>>(app.world_mut()),
-            Some(Some("two".to_string())),
-            "Initial value for present key is incorrect"
-        );
-
-        // Test 2: Update Tracked Key's Value. This should cause the signal to emit the
-        // new value.
-        source_map.write().insert(key_to_track, "two_v2".to_string());
-        source_map.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_output::<Option<String>>(app.world_mut()),
-            Some(Some("two_v2".to_string())),
-            "Update to tracked key did not emit correctly"
-        );
-
-        // Test 3: Update a Different Key. This should NOT cause the signal to emit, as
-        // our key's value hasn't changed.
-        clear_output::<Option<String>>(app.world_mut());
-        source_map.write().insert(1, "one_v2".to_string());
-        source_map.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_output::<Option<String>>(app.world_mut()),
-            None,
-            "Signal emitted when a different key was updated"
-        );
-
-        // Test 4: Remove Tracked Key. This should cause the signal to emit `None`.
-        source_map.write().remove(&key_to_track);
-        source_map.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_output::<Option<String>>(app.world_mut()),
-            Some(None),
-            "Removing the tracked key did not emit None"
-        );
-
-        // Test 5: No Change (Key is Absent). Another update with the key still absent
-        // should not emit.
-        clear_output::<Option<String>>(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_output::<Option<String>>(app.world_mut()),
-            None,
-            "Signal emitted when key remained absent"
-        );
-
-        // Test 6: Re-insert Tracked Key. This should cause the signal to emit the new
-        // value.
-        source_map.write().insert(key_to_track, "two_reborn".to_string());
-        source_map.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_output::<Option<String>>(app.world_mut()),
-            Some(Some("two_reborn".to_string())),
-            "Re-inserting the tracked key did not emit its value"
-        );
-
-        // Test 7: Clear the map. Since this removes the key, it should emit `None`.
-        source_map.write().clear();
-        source_map.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_output::<Option<String>>(app.world_mut()),
-            Some(None),
-            "Clearing the map did not emit None for the tracked key"
-        );
-        handle.cleanup(app.world_mut());
+        {
+            let mut app = create_test_app();
+
+            // The output is a Signal<Option`<String>`>.
+            app.init_resource::<SignalOutput<Option<String>>>();
+            let source_map =
+                (MutableBTreeMapBuilder::from([(1, "one".to_string()), (2, "two".to_string())])).spawn(app.world_mut());
+
+            // We will specifically track the value associated with key `2`.
+            let key_to_track = 2;
+            let key_signal = source_map.signal_map().key(key_to_track);
+            let handle = key_signal
+                .map(capture_output::<Option<String>>)
+                .register(app.world_mut());
+
+            // Test 1: Initial State (Key is Present). The first update should emit the
+            // initial value for the key.
+            app.update();
+            assert_eq!(
+                get_output::<Option<String>>(app.world_mut()),
+                Some(Some("two".to_string())),
+                "Initial value for present key is incorrect"
+            );
+
+            // Test 2: Update Tracked Key's Value. This should cause the signal to emit the
+            // new value.
+            source_map
+                .write(app.world_mut())
+                .insert(key_to_track, "two_v2".to_string());
+            app.update();
+            assert_eq!(
+                get_output::<Option<String>>(app.world_mut()),
+                Some(Some("two_v2".to_string())),
+                "Update to tracked key did not emit correctly"
+            );
+
+            // Test 3: Update a Different Key. This should NOT cause the signal to emit, as
+            // our key's value hasn't changed.
+            clear_output::<Option<String>>(app.world_mut());
+            source_map.write(app.world_mut()).insert(1, "one_v2".to_string());
+            app.update();
+            assert_eq!(
+                get_output::<Option<String>>(app.world_mut()),
+                None,
+                "Signal emitted when a different key was updated"
+            );
+
+            // Test 4: Remove Tracked Key. This should cause the signal to emit `None`.
+            source_map.write(app.world_mut()).remove(&key_to_track);
+            app.update();
+            assert_eq!(
+                get_output::<Option<String>>(app.world_mut()),
+                Some(None),
+                "Removing the tracked key did not emit None"
+            );
+
+            // Test 5: No Change (Key is Absent). Another update with the key still absent
+            // should not emit.
+            clear_output::<Option<String>>(app.world_mut());
+            app.update();
+            assert_eq!(
+                get_output::<Option<String>>(app.world_mut()),
+                None,
+                "Signal emitted when key remained absent"
+            );
+
+            // Test 6: Re-insert Tracked Key. This should cause the signal to emit the new
+            // value.
+            source_map
+                .write(app.world_mut())
+                .insert(key_to_track, "two_reborn".to_string());
+            app.update();
+            assert_eq!(
+                get_output::<Option<String>>(app.world_mut()),
+                Some(Some("two_reborn".to_string())),
+                "Re-inserting the tracked key did not emit its value"
+            );
+
+            // Test 7: Clear the map. Since this removes the key, it should emit `None`.
+            source_map.write(app.world_mut()).clear();
+            app.update();
+            assert_eq!(
+                get_output::<Option<String>>(app.world_mut()),
+                Some(None),
+                "Clearing the map did not emit None for the tracked key"
+            );
+            handle.cleanup(app.world_mut());
+        }
+
+        cleanup(true);
     }
 
     #[derive(Resource, Default, Debug)]
@@ -1675,7 +1805,7 @@ mod tests {
             .unwrap_or_default()
     }
 
-    fn apply_diffs_to_vec<T: Clone>(vec: &mut Vec<T>, diffs: &[VecDiff<T>]) {
+    fn apply_diffs_to_vec<T: Clone>(vec: &mut Vec<T>, diffs: Vec<VecDiff<T>>) {
         for diff in diffs {
             diff.apply_to_vec(vec);
         }
@@ -1684,223 +1814,220 @@ mod tests {
     // ADD: The comprehensive unit test for `signal_vec_keys`.
     #[test]
     fn test_signal_vec_keys() {
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-        app.init_resource::<SignalVecOutput<u32>>(); // Keys are u32
-
-        // Start with unsorted data to verify initial sort.
-        let source_map = MutableBTreeMap::from([(3, 'c'), (1, 'a'), (4, 'd')]);
-
-        let keys_signal = source_map.signal_vec_keys();
-        let handle = keys_signal
-            .for_each(capture_vec_output::<u32>)
-            .register(app.world_mut());
-
-        // Local mirror of the key state for verification.
-        let mut current_keys: Vec<u32> = vec![];
-
-        // --- 2. Test Initial State ---
-        app.update();
-        let diffs = get_and_clear_vec_output::<u32>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Initial update should produce one Replace diff.");
-        assert_eq!(
-            diffs[0],
-            VecDiff::Replace { values: vec![1, 3, 4] },
-            "Initial state should be a Replace with sorted keys."
-        );
-        apply_diffs_to_vec(&mut current_keys, &diffs);
-        assert_eq!(current_keys, vec![1, 3, 4]);
-
-        // --- 3. Test Insert ---
-        // Insert a key that goes in the middle.
-        source_map.write().insert(2, 'b');
-        source_map.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_vec_output::<u32>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(diffs[0], VecDiff::InsertAt { index: 1, value: 2 });
-        apply_diffs_to_vec(&mut current_keys, &diffs);
-        assert_eq!(current_keys, vec![1, 2, 3, 4]);
-
-        // Insert a key at the beginning.
-        source_map.write().insert(0, 'z');
-        source_map.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_vec_output::<u32>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(diffs[0], VecDiff::InsertAt { index: 0, value: 0 });
-        apply_diffs_to_vec(&mut current_keys, &diffs);
-        assert_eq!(current_keys, vec![0, 1, 2, 3, 4]);
-
-        // --- 4. Test Update (No Key Change) ---
-        // This should produce NO diffs for the keys vector.
-        source_map.write().insert(3, 'C'); // Update value for key 3
-        source_map.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_vec_output::<u32>(app.world_mut());
-        assert!(diffs.is_empty(), "Updating a value should not produce a key diff.");
-        assert_eq!(current_keys, vec![0, 1, 2, 3, 4]); // State unchanged
-
-        // --- 5. Test Remove ---
-        // Remove key '3' from the middle of the sorted list.
-        source_map.write().remove(&3);
-        source_map.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_vec_output::<u32>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(diffs[0], VecDiff::RemoveAt { index: 3 }); // '3' was at index 3
-        apply_diffs_to_vec(&mut current_keys, &diffs);
-        assert_eq!(current_keys, vec![0, 1, 2, 4]);
-
-        // --- 6. Test Batched Diffs ---
         {
-            let mut writer = source_map.write();
-            writer.remove(&1); // current_keys should become [0, 2, 4]
-            writer.insert(5, 'e'); // current_keys should become [0, 2, 4, 5]
+            // --- 1. Setup ---
+            let mut app = create_test_app();
+            app.init_resource::<SignalVecOutput<u32>>(); // Keys are u32
+
+            // Start with unsorted data to verify initial sort.
+            let source_map = (MutableBTreeMapBuilder::from([(3, 'c'), (1, 'a'), (4, 'd')])).spawn(app.world_mut());
+
+            let keys_signal = source_map.signal_vec_keys();
+            let handle = keys_signal
+                .for_each(capture_vec_output::<u32>)
+                .register(app.world_mut());
+
+            // Local mirror of the key state for verification.
+            let mut current_keys: Vec<u32> = vec![];
+
+            // --- 2. Test Initial State ---
+            app.update();
+            let diffs = get_and_clear_vec_output::<u32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Initial update should produce one Replace diff.");
+            assert_eq!(
+                diffs[0],
+                VecDiff::Replace { values: vec![1, 3, 4] },
+                "Initial state should be a Replace with sorted keys."
+            );
+            apply_diffs_to_vec(&mut current_keys, diffs);
+            assert_eq!(current_keys, vec![1, 3, 4]);
+
+            // --- 3. Test Insert ---
+            // Insert a key that goes in the middle.
+            source_map.write(app.world_mut()).insert(2, 'b');
+            app.update();
+            let diffs = get_and_clear_vec_output::<u32>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(diffs[0], VecDiff::InsertAt { index: 1, value: 2 });
+            apply_diffs_to_vec(&mut current_keys, diffs);
+            assert_eq!(current_keys, vec![1, 2, 3, 4]);
+
+            // Insert a key at the beginning.
+            source_map.write(app.world_mut()).insert(0, 'z');
+            app.update();
+            let diffs = get_and_clear_vec_output::<u32>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(diffs[0], VecDiff::InsertAt { index: 0, value: 0 });
+            apply_diffs_to_vec(&mut current_keys, diffs);
+            assert_eq!(current_keys, vec![0, 1, 2, 3, 4]);
+
+            // --- 4. Test Update (No Key Change) ---
+            // This should produce NO diffs for the keys vector.
+            source_map.write(app.world_mut()).insert(3, 'C'); // Update value for key 3
+            app.update();
+            let diffs = get_and_clear_vec_output::<u32>(app.world_mut());
+            assert!(diffs.is_empty(), "Updating a value should not produce a key diff.");
+            assert_eq!(current_keys, vec![0, 1, 2, 3, 4]); // State unchanged
+
+            // --- 5. Test Remove ---
+            // Remove key '3' from the middle of the sorted list.
+            source_map.write(app.world_mut()).remove(&3);
+            app.update();
+            let diffs = get_and_clear_vec_output::<u32>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(diffs[0], VecDiff::RemoveAt { index: 3 }); // '3' was at index 3
+            apply_diffs_to_vec(&mut current_keys, diffs);
+            assert_eq!(current_keys, vec![0, 1, 2, 4]);
+
+            // --- 6. Test Batched Diffs ---
+            {
+                let mut writer = source_map.write(app.world_mut());
+                writer.remove(&1); // current_keys should become [0, 2, 4]
+                writer.insert(5, 'e'); // current_keys should become [0, 2, 4, 5]
+            }
+            app.update();
+            let diffs = get_and_clear_vec_output::<u32>(app.world_mut());
+            assert_eq!(
+                diffs,
+                vec![VecDiff::RemoveAt { index: 1 }, VecDiff::InsertAt { index: 3, value: 5 }],
+                "Batched diffs were not processed correctly."
+            );
+            apply_diffs_to_vec(&mut current_keys, diffs);
+            assert_eq!(
+                current_keys,
+                vec![0, 2, 4, 5],
+                "State after batched diffs is incorrect."
+            );
+
+            // --- 7. Test Clear ---
+            source_map.write(app.world_mut()).clear();
+            app.update();
+            let diffs = get_and_clear_vec_output::<u32>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(diffs[0], VecDiff::Clear);
+            apply_diffs_to_vec(&mut current_keys, diffs);
+            assert!(current_keys.is_empty());
+
+            // --- 8. Cleanup ---
+            handle.cleanup(app.world_mut());
         }
-        source_map.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_vec_output::<u32>(app.world_mut());
-        assert_eq!(
-            diffs,
-            vec![VecDiff::RemoveAt { index: 1 }, VecDiff::InsertAt { index: 3, value: 5 }],
-            "Batched diffs were not processed correctly."
-        );
-        apply_diffs_to_vec(&mut current_keys, &diffs);
-        assert_eq!(
-            current_keys,
-            vec![0, 2, 4, 5],
-            "State after batched diffs is incorrect."
-        );
-
-        // --- 7. Test Clear ---
-        source_map.write().clear();
-        source_map.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_vec_output::<u32>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(diffs[0], VecDiff::Clear);
-        apply_diffs_to_vec(&mut current_keys, &diffs);
-        assert!(current_keys.is_empty());
-
-        // --- 8. Cleanup ---
-        handle.cleanup(app.world_mut());
+
+        cleanup(true);
     }
 
     #[test]
     fn test_signal_vec_entries() {
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-        app.init_resource::<SignalVecOutput<(u32, char)>>(); // Entries are (u32, char)
-
-        // Start with unsorted data to verify initial sort.
-        let source_map = MutableBTreeMap::from([(3, 'c'), (1, 'a'), (4, 'd')]);
-
-        let entries_signal = source_map.signal_vec_entries();
-        let handle = entries_signal
-            .for_each(capture_vec_output::<(u32, char)>)
-            .register(app.world_mut());
-
-        // Local mirror of the entry state for verification.
-        let mut current_entries: Vec<(u32, char)> = vec![];
-
-        // --- 2. Test Initial State ---
-        app.update();
-        let diffs = get_and_clear_vec_output::<(u32, char)>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Initial update should produce one Replace diff.");
-        assert_eq!(
-            diffs[0],
-            VecDiff::Replace {
-                values: vec![(1, 'a'), (3, 'c'), (4, 'd')]
-            },
-            "Initial state should be a Replace with sorted entries."
-        );
-        apply_diffs_to_vec(&mut current_entries, &diffs);
-        assert_eq!(current_entries, vec![(1, 'a'), (3, 'c'), (4, 'd')]);
-
-        // --- 3. Test Insert ---
-        // Insert an entry that goes in the middle of the sorted list.
-        source_map.write().insert(2, 'b');
-        source_map.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_vec_output::<(u32, char)>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(
-            diffs[0],
-            VecDiff::InsertAt {
-                index: 1,
-                value: (2, 'b')
-            }
-        );
-        apply_diffs_to_vec(&mut current_entries, &diffs);
-        assert_eq!(current_entries, vec![(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]);
-
-        // --- 4. Test Update ---
-        // Update the value for an existing key. The index should remain the same.
-        source_map.write().insert(3, 'C'); // Update value for key 3
-        source_map.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_vec_output::<(u32, char)>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(
-            diffs[0],
-            VecDiff::UpdateAt {
-                index: 2, // '3' is at index 2 in the sorted list
-                value: (3, 'C')
-            }
-        );
-        apply_diffs_to_vec(&mut current_entries, &diffs);
-        assert_eq!(current_entries, vec![(1, 'a'), (2, 'b'), (3, 'C'), (4, 'd')]);
-
-        // --- 5. Test Remove ---
-        // Remove key '1' from the beginning of the sorted list.
-        source_map.write().remove(&1);
-        source_map.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_vec_output::<(u32, char)>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(diffs[0], VecDiff::RemoveAt { index: 0 }); // '1' was at index 0
-        apply_diffs_to_vec(&mut current_entries, &diffs);
-        assert_eq!(current_entries, vec![(2, 'b'), (3, 'C'), (4, 'd')]);
-
-        // --- 6. Test Batched Diffs ---
         {
-            let mut writer = source_map.write();
-            writer.remove(&4); // current_entries should become [(2, 'b'), (3, 'C')]
-            writer.insert(0, 'z'); // current_entries should become [(0, 'z'), (2, 'b'), (3, 'C')]
-        }
-        source_map.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_vec_output::<(u32, char)>(app.world_mut());
-        assert_eq!(
-            diffs,
-            vec![
-                VecDiff::RemoveAt { index: 2 }, // '4' was at index 2
+            // --- 1. Setup ---
+            let mut app = create_test_app();
+            app.init_resource::<SignalVecOutput<(u32, char)>>(); // Entries are (u32, char)
+
+            // Start with unsorted data to verify initial sort.
+            let source_map = (MutableBTreeMapBuilder::from([(3, 'c'), (1, 'a'), (4, 'd')])).spawn(app.world_mut());
+
+            let entries_signal = source_map.signal_vec_entries();
+            let handle = entries_signal
+                .for_each(capture_vec_output::<(u32, char)>)
+                .register(app.world_mut());
+
+            // Local mirror of the entry state for verification.
+            let mut current_entries: Vec<(u32, char)> = vec![];
+
+            // --- 2. Test Initial State ---
+            app.update();
+            let diffs = get_and_clear_vec_output::<(u32, char)>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Initial update should produce one Replace diff.");
+            assert_eq!(
+                diffs[0],
+                VecDiff::Replace {
+                    values: vec![(1, 'a'), (3, 'c'), (4, 'd')]
+                },
+                "Initial state should be a Replace with sorted entries."
+            );
+            apply_diffs_to_vec(&mut current_entries, diffs);
+            assert_eq!(current_entries, vec![(1, 'a'), (3, 'c'), (4, 'd')]);
+
+            // --- 3. Test Insert ---
+            // Insert an entry that goes in the middle of the sorted list.
+            source_map.write(app.world_mut()).insert(2, 'b');
+            app.update();
+            let diffs = get_and_clear_vec_output::<(u32, char)>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(
+                diffs[0],
                 VecDiff::InsertAt {
-                    index: 0,
-                    value: (0, 'z')
-                }  // '0' is inserted at index 0
-            ],
-            "Batched diffs were not processed correctly."
-        );
-        apply_diffs_to_vec(&mut current_entries, &diffs);
-        assert_eq!(
-            current_entries,
-            vec![(0, 'z'), (2, 'b'), (3, 'C')],
-            "State after batched diffs is incorrect."
-        );
-
-        // --- 7. Test Clear ---
-        source_map.write().clear();
-        source_map.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_vec_output::<(u32, char)>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(diffs[0], VecDiff::Clear);
-        apply_diffs_to_vec(&mut current_entries, &diffs);
-        assert!(current_entries.is_empty());
-
-        // --- 8. Cleanup ---
-        handle.cleanup(app.world_mut());
+                    index: 1,
+                    value: (2, 'b')
+                }
+            );
+            apply_diffs_to_vec(&mut current_entries, diffs);
+            assert_eq!(current_entries, vec![(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]);
+
+            // --- 4. Test Update ---
+            // Update the value for an existing key. The index should remain the same.
+            source_map.write(app.world_mut()).insert(3, 'C'); // Update value for key 3
+            app.update();
+            let diffs = get_and_clear_vec_output::<(u32, char)>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(
+                diffs[0],
+                VecDiff::UpdateAt {
+                    index: 2, // '3' is at index 2 in the sorted list
+                    value: (3, 'C')
+                }
+            );
+            apply_diffs_to_vec(&mut current_entries, diffs);
+            assert_eq!(current_entries, vec![(1, 'a'), (2, 'b'), (3, 'C'), (4, 'd')]);
+
+            // --- 5. Test Remove ---
+            // Remove key '1' from the beginning of the sorted list.
+            source_map.write(app.world_mut()).remove(&1);
+            app.update();
+            let diffs = get_and_clear_vec_output::<(u32, char)>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(diffs[0], VecDiff::RemoveAt { index: 0 }); // '1' was at index 0
+            apply_diffs_to_vec(&mut current_entries, diffs);
+            assert_eq!(current_entries, vec![(2, 'b'), (3, 'C'), (4, 'd')]);
+
+            // --- 6. Test Batched Diffs ---
+            {
+                let mut writer = source_map.write(app.world_mut());
+                writer.remove(&4); // current_entries should become [(2, 'b'), (3, 'C')]
+                writer.insert(0, 'z'); // current_entries should become [(0, 'z'), (2, 'b'), (3, 'C')]
+            }
+            app.update();
+            let diffs = get_and_clear_vec_output::<(u32, char)>(app.world_mut());
+            assert_eq!(
+                diffs,
+                vec![
+                    VecDiff::RemoveAt { index: 2 }, // '4' was at index 2
+                    VecDiff::InsertAt {
+                        index: 0,
+                        value: (0, 'z')
+                    }  // '0' is inserted at index 0
+                ],
+                "Batched diffs were not processed correctly."
+            );
+            apply_diffs_to_vec(&mut current_entries, diffs);
+            assert_eq!(
+                current_entries,
+                vec![(0, 'z'), (2, 'b'), (3, 'C')],
+                "State after batched diffs is incorrect."
+            );
+
+            // --- 7. Test Clear ---
+            source_map.write(app.world_mut()).clear();
+            app.update();
+            let diffs = get_and_clear_vec_output::<(u32, char)>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(diffs[0], VecDiff::Clear);
+            apply_diffs_to_vec(&mut current_entries, diffs);
+            assert!(current_entries.is_empty());
+
+            // --- 8. Cleanup ---
+            handle.cleanup(app.world_mut());
+        }
+
+        cleanup(true);
     }
 }
diff --git a/src/signal_vec.rs b/src/signal_vec.rs
index cd78ed0..1369ca5 100644
--- a/src/signal_vec.rs
+++ b/src/signal_vec.rs
@@ -2,8 +2,8 @@
 //! [`Vec`] mutations, see [`MutableVec`] and [`SignalVecExt`].
 use super::{
     graph::{
-        LazySignal, LazySystem, SignalHandle, SignalSystem, Upstream, downcast_any_clone, lazy_signal_from_system,
-        pipe_signal, poll_signal, process_signals, register_signal,
+        LazySignal, SignalHandle, SignalSystem, Upstream, downcast_any_clone, lazy_signal_from_system, pipe_signal,
+        poll_signal, process_signals, register_signal,
     },
     signal::{Signal, SignalBuilder, SignalExt},
     utils::{LazyEntity, SSs},
@@ -16,9 +16,9 @@ use bevy_log::debug;
 use bevy_platform::{
     collections::HashMap,
     prelude::*,
-    sync::{Arc, RwLock, RwLockReadGuard, RwLockWriteGuard},
+    sync::{Arc, LazyLock, Mutex},
 };
-use core::{cmp::Ordering, fmt, marker::PhantomData, ops::Deref};
+use core::{cmp::Ordering, fmt, marker::PhantomData, ops::Deref, sync::atomic::AtomicUsize};
 use dyn_clone::{DynClone, clone_trait_object};
 
 /// Describes the mutations made to the underlying [`MutableVec`] that are piped to downstream
@@ -92,29 +92,29 @@ where
     }
 }
 
-impl<T: Clone> VecDiff<T> {
+impl<T> VecDiff<T> {
     #[allow(missing_docs)]
-    pub fn apply_to_vec(&self, vec: &mut Vec<T>) {
+    pub fn apply_to_vec(self, vec: &mut Vec<T>) {
         match self {
-            VecDiff::Replace { values } => *vec = values.clone(),
-            VecDiff::InsertAt { index, value } => vec.insert(*index, value.clone()),
+            VecDiff::Replace { values } => *vec = values,
+            VecDiff::InsertAt { index, value } => vec.insert(index, value),
             VecDiff::UpdateAt { index, value } => {
-                if let Some(elem) = vec.get_mut(*index) {
-                    *elem = value.clone();
+                if let Some(elem) = vec.get_mut(index) {
+                    *elem = value;
                 }
             }
             VecDiff::RemoveAt { index } => {
-                if *index < vec.len() {
-                    vec.remove(*index);
+                if index < vec.len() {
+                    vec.remove(index);
                 }
             }
             VecDiff::Move { old_index, new_index } => {
-                if *old_index < vec.len() {
-                    let val = vec.remove(*old_index);
-                    vec.insert(*new_index, val);
+                if old_index < vec.len() {
+                    let val = vec.remove(old_index);
+                    vec.insert(new_index, val);
                 }
             }
-            VecDiff::Push { value } => vec.push(value.clone()),
+            VecDiff::Push { value } => vec.push(value),
             VecDiff::Pop => {
                 vec.pop();
             }
@@ -157,13 +157,13 @@ impl<O: 'static> SignalVec for Box<dyn SignalVec<Item = O> + Send + Sync> {
 /// Relevant in contexts where some function may require a [`Clone`] [`SignalVec`], but the concrete
 /// type can't be known at compile-time, e.g. in a
 /// [`.switch_signal_vec`](SignalExt::switch_signal_vec).
-pub trait SignalVecClone: SignalVec + DynClone {}
+pub trait SignalVecDynClone: SignalVec + DynClone {}
 
-clone_trait_object!(< T > SignalVecClone < Item = T >);
+clone_trait_object!(<T> SignalVecDynClone<Item = T>);
 
-impl<T: SignalVec + Clone + 'static> SignalVecClone for T {}
+impl<T: SignalVec + Clone + 'static> SignalVecDynClone for T {}
 
-impl<O: 'static> SignalVec for Box<dyn SignalVecClone<Item = O> + Send + Sync> {
+impl<O: 'static> SignalVec for Box<dyn SignalVecDynClone<Item = O> + Send + Sync> {
     type Item = O;
 
     fn register_boxed_signal_vec(self: Box<Self>, world: &mut World) -> SignalHandle {
@@ -474,7 +474,7 @@ fn spawn_filter_signal<T: Clone + SSs>(
 ) -> (SignalHandle, bool) {
     let entity = LazyEntity::new();
     let processor_system = clone!((entity) move |In(filter): In<bool>, world: &mut World| {
-        let self_entity = entity.get();
+        let self_entity = *entity;
 
         // The processor might run after its parent has been cleaned up.
         let Ok(signal_index_comp) = world.query::<&FilterSignalIndex>().get(world, self_entity) else {
@@ -1101,7 +1101,11 @@ pub trait SignalVecExt: SignalVec {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// MutableVec::from([1, 2, 3]).signal_vec().map(|In(x): In<i32>| x * 2); // outputs `SignalVec -> [2, 4, 6]`
+    /// let mut world = World::new();
+    /// MutableVecBuilder::from([1, 2, 3])
+    ///     .spawn(&mut world)
+    ///     .signal_vec()
+    ///     .map(|In(x): In<i32>| x * 2); // outputs `SignalVec -> [2, 4, 6]`
     /// ```
     fn map<O, F, M>(self, system: F) -> Map<Self, O>
     where
@@ -1180,7 +1184,11 @@ pub trait SignalVecExt: SignalVec {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// MutableVec::from([1, 2, 3]).signal_vec().map_in(|x: i32| x * 2); // outputs `SignalVec -> [2, 4, 6]`
+    /// let mut world = World::new();
+    /// MutableVecBuilder::from([1, 2, 3])
+    ///     .spawn(&mut world)
+    ///     .signal_vec()
+    ///     .map_in(|x: i32| x * 2); // outputs `SignalVec -> [2, 4, 6]`
     /// ```
     fn map_in<O, F>(self, mut function: F) -> Map<Self, O>
     where
@@ -1204,7 +1212,11 @@ pub trait SignalVecExt: SignalVec {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// MutableVec::from([1, 2, 3]).signal_vec().map_in_ref(ToString::to_string); // outputs `SignalVec -> ["1", "2", "3"]`
+    /// let mut world = World::new();
+    /// MutableVecBuilder::from([1, 2, 3])
+    ///     .spawn(&mut world)
+    ///     .signal_vec()
+    ///     .map_in_ref(ToString::to_string); // outputs `SignalVec -> ["1", "2", "3"]`
     /// ```
     fn map_in_ref<O, F>(self, mut function: F) -> Map<Self, O>
     where
@@ -1225,7 +1237,10 @@ pub trait SignalVecExt: SignalVec {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// MutableVec::from([1, 2, 3]).signal_vec()
+    /// let mut world = World::new();
+    /// MutableVecBuilder::from([1, 2, 3])
+    ///     .spawn(&mut world)
+    ///     .signal_vec()
     ///     .map_signal(|In(x): In<i32>|
     ///         SignalBuilder::from_system(move |_: In<()>| x * 2).dedupe()
     ///     ); // outputs `SignalVec -> [2, 4, 6]`
@@ -1527,7 +1542,11 @@ pub trait SignalVecExt: SignalVec {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// MutableVec::from([1, 2, 3, 4]).signal_vec().filter(|In(x): In<i32>| x % 2 == 0); // outputs `SignalVec -> [2, 4]`
+    /// let mut world = World::new();
+    /// MutableVecBuilder::from([1, 2, 3, 4])
+    ///     .spawn(&mut world)
+    ///     .signal_vec()
+    ///     .filter(|In(x): In<i32>| x % 2 == 0); // outputs `SignalVec -> [2, 4]`
     /// ```
     fn filter<F, M>(self, predicate: F) -> Filter<Self>
     where
@@ -1572,7 +1591,10 @@ pub trait SignalVecExt: SignalVec {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// MutableVec::from(["1", "two", "NaN", "four", "5"]).signal_vec()
+    /// let mut world = World::new();
+    /// MutableVecBuilder::from(["1", "two", "NaN", "four", "5"])
+    ///     .spawn(&mut world)
+    ///     .signal_vec()
     ///     .filter_map(|In(s): In<&'static str>| s.parse::<u32>().ok()); // outputs `SignalVec -> [1, 5]`
     /// ```
     fn filter_map<O, F, M>(self, system: F) -> FilterMap<Self, O>
@@ -1614,7 +1636,10 @@ pub trait SignalVecExt: SignalVec {
     /// #[derive(Resource, Clone)]
     /// struct Even(bool);
     ///
-    /// MutableVec::from([1, 2, 3, 4]).signal_vec()
+    /// let mut world = World::new();
+    /// MutableVecBuilder::from([1, 2, 3, 4])
+    ///      .spawn(&mut world)
+    ///      .signal_vec()
     ///      .filter_signal(|In(x): In<i32>| {
     ///          SignalBuilder::from_resource().map_in(move |even: Even| x % 2 == if even.0 { 0 } else { 1 })
     ///      }); // outputs `SignalVec -> [2, 4]` when `Even(true)` and `SignalVec -> [1, 3]` when `Even(false)`
@@ -1961,11 +1986,10 @@ pub trait SignalVecExt: SignalVec {
     /// use jonmo::prelude::*;
     ///
     /// let mut world = World::new();
-    /// let mut vec = MutableVec::from([1, 2, 5]);
+    /// let mut vec = MutableVecBuilder::from([1, 2, 5]).spawn(&mut world);
     /// let signal = vec.signal_vec().enumerate();
     /// // signal outputs `SignalVec -> [(Signal -> Some(0), 1), (Signal -> Some(1), 2), (Signal -> Some(2), 5)]`
-    /// vec.write().remove(1);
-    /// world.commands().queue(vec.flush());
+    /// vec.write(&mut world).remove(1);
     /// // signal outputs `SignalVec -> [(Signal -> Some(0), 1), (Signal -> Some(1), 5)]`
     /// ```
     fn enumerate(self) -> Enumerate<Self>
@@ -2133,7 +2157,12 @@ pub trait SignalVecExt: SignalVec {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// MutableVec::from([1, 2, 3]).signal_vec().to_signal().map_in(|vec: Vec<i32>| vec[1]); // outputs `2`
+    /// let mut world = World::new();
+    /// MutableVecBuilder::from([1, 2, 3])
+    ///     .spawn(&mut world)
+    ///     .signal_vec()
+    ///     .to_signal()
+    ///     .map_in(|vec: Vec<i32>| vec[1]); // outputs `2`
     /// ```
     fn to_signal(self) -> ToSignal<Self>
     where
@@ -2185,11 +2214,10 @@ pub trait SignalVecExt: SignalVec {
     /// use jonmo::prelude::*;
     ///
     /// let mut world = World::new();
-    /// let mut vec = MutableVec::from([1]);
+    /// let mut vec = MutableVecBuilder::from([1]).spawn(&mut world);
     /// let signal = vec.signal_vec().is_empty();
     /// // `signal` outputs `false`
-    /// vec.write().pop();
-    /// world.commands().queue(vec.flush());
+    /// vec.write(&mut world).pop();
     /// // `signal` outputs `true`
     /// ```
     #[allow(clippy::wrong_self_convention)]
@@ -2212,11 +2240,10 @@ pub trait SignalVecExt: SignalVec {
     /// use jonmo::prelude::*;
     ///
     /// let mut world = World::new();
-    /// let mut vec = MutableVec::from([1]);
+    /// let mut vec = MutableVecBuilder::from([1]).spawn(&mut world);
     /// let signal = vec.signal_vec().is_empty();
     /// // `signal` outputs `1`
-    /// vec.write().pop();
-    /// world.commands().queue(vec.flush());
+    /// vec.write(&mut world).pop();
     /// // `signal` outputs `0`
     /// ```
     fn len(self) -> Len<Self>
@@ -2238,11 +2265,10 @@ pub trait SignalVecExt: SignalVec {
     /// use jonmo::prelude::*;
     ///
     /// let mut world = World::new();
-    /// let mut vec = MutableVec::from([1, 2, 3]);
+    /// let mut vec = MutableVecBuilder::from([1, 2, 3]).spawn(&mut world);
     /// let signal = vec.signal_vec().is_empty();
     /// // `signal` outputs `6`
-    /// vec.write().push(4);
-    /// world.commands().queue(vec.flush());
+    /// vec.write(&mut world).push(4);
     /// // `signal` outputs `10`
     /// ```
     fn sum(self) -> Sum<Self>
@@ -2267,7 +2293,15 @@ pub trait SignalVecExt: SignalVec {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// MutableVec::from([1, 3]).signal_vec().chain(MutableVec::from([2, 4]).signal_vec()); // outputs `SignalVec -> [1, 3, 2, 4]`
+    /// let mut world = World::new();
+    /// MutableVecBuilder::from([1, 3])
+    ///     .spawn(&mut world)
+    ///     .signal_vec()
+    ///     .chain(
+    ///         MutableVecBuilder::from([2, 4])
+    ///             .spawn(&mut world)
+    ///             .signal_vec(),
+    ///     ); // outputs `SignalVec -> [1, 3, 2, 4]`
     /// ```
     fn chain<S>(self, other: S) -> Chain<Self, S>
     where
@@ -2426,7 +2460,11 @@ pub trait SignalVecExt: SignalVec {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// MutableVec::from([1, 2, 3]).signal_vec().intersperse(0); // outputs `SignalVec -> [1, 0, 2, 0, 3]`
+    /// let mut world = World::new();
+    /// MutableVecBuilder::from([1, 2, 3])
+    ///     .spawn(&mut world)
+    ///     .signal_vec()
+    ///     .intersperse(0); // outputs `SignalVec -> [1, 0, 2, 0, 3]`
     /// ```
     fn intersperse(self, separator: Self::Item) -> Intersperse<Self>
     where
@@ -2563,7 +2601,8 @@ pub trait SignalVecExt: SignalVec {
     /// use jonmo::prelude::*;
     /// use jonmo::signal::{Dedupe, Source};
     ///
-    /// MutableVec::from([1, 2, 3]).signal_vec().intersperse_with(|_: In<Source<Option<usize>>| 0); // outputs `SignalVec -> [1, 0, 2, 0, 3]`
+    /// let mut world = World::new();
+    /// MutableVec::from([1, 2, 3]).spawn(&mut world).signal_vec().intersperse_with(|_: In<Source<Option<usize>>| 0); // outputs `SignalVec -> [1, 0, 2, 0, 3]`
     /// ```
     fn intersperse_with<F, M>(self, separator_system: F) -> IntersperseWith<Self>
     where
@@ -2863,7 +2902,8 @@ pub trait SignalVecExt: SignalVec {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// MutableVec::from([3, 2, 1]).signal_vec().sort_by(|In((left, right)): In<(i32, i32)>| left.cmp(&right)); // outputs `SignalVec -> [1, 2, 3]`
+    /// let mut world = World::new();
+    /// MutableVecBuilder::from([3, 2, 1]).spawn(&mut world).signal_vec().sort_by(|In((left, right)): In<(i32, i32)>| left.cmp(&right)); // outputs `SignalVec -> [1, 2, 3]`
     /// ```
     fn sort_by<F, M>(self, compare_system: F) -> SortBy<Self>
     where
@@ -3045,7 +3085,11 @@ pub trait SignalVecExt: SignalVec {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// MutableVec::from([3, 2, 1]).signal_vec().sort_by_cmp(); // outputs `SignalVec -> [1, 2, 3]`
+    /// let mut world = World::new();
+    /// MutableVecBuilder::from([3, 2, 1])
+    ///     .spawn(&mut world)
+    ///     .signal_vec()
+    ///     .sort_by_cmp(); // outputs `SignalVec -> [1, 2, 3]`
     /// ```
     fn sort_by_cmp(self) -> SortBy<Self>
     where
@@ -3065,7 +3109,11 @@ pub trait SignalVecExt: SignalVec {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// MutableVec::from([3, 2, 1]).signal_vec().sort_by_key(|In(x): In<i32>| -x); // outputs `SignalVec -> [1, 2, 3]`
+    /// let mut world = World::new();
+    /// MutableVecBuilder::from([3, 2, 1])
+    ///     .spawn(&mut world)
+    ///     .signal_vec()
+    ///     .sort_by_key(|In(x): In<i32>| -x); // outputs `SignalVec -> [1, 2, 3]`
     /// ```
     fn sort_by_key<K, F, M>(self, system: F) -> SortByKey<Self>
     where
@@ -3417,11 +3465,10 @@ pub trait SignalVecExt: SignalVec {
     /// use jonmo::prelude::*;
     ///
     /// let mut world = World::new();
-    /// let mut vec = MutableVec::from([1, 2, 3]);
+    /// let mut vec = MutableVecBuilder::from([1, 2, 3]).spawn(&mut world);
     /// let signal = vec.signal_vec().debug();
     /// // signal logs `[ Replace { values: [ 1, 2, 3 ] } ]`
-    /// vec.write().push(4);
-    /// world.commands().queue(vec.flush());
+    /// vec.write(&mut world).push(4);
     /// // signal logs `[ Push { value: 4 } ]`
     /// ```
     fn debug(self) -> Debug<Self>
@@ -3447,11 +3494,20 @@ pub trait SignalVecExt: SignalVec {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
+    /// let mut world = World::new();
     /// let condition = true;
     /// let signal = if condition {
-    ///     MutableVec::from([1, 2, 3]).signal_vec().map_in(|x: i32| x * 2).boxed() // this is a `Map<Source<i32>>`
+    ///     MutableVecBuilder::from([1, 2, 3])
+    ///         .spawn(&mut world)
+    ///         .signal_vec()
+    ///         .map_in(|x: i32| x * 2)
+    ///         .boxed() // this is a `Map<Source<i32>>`
     /// } else {
-    ///     MutableVec::from([1, 2, 3]).signal_vec().filter(|In(x): In<i32>| x % 2 == 0).boxed() // this is a `Filter<Source<i32>>`
+    ///     MutableVecBuilder::from([1, 2, 3])
+    ///         .spawn(&mut world)
+    ///         .signal_vec()
+    ///         .filter(|In(x): In<i32>| x % 2 == 0)
+    ///         .boxed() // this is a `Filter<Source<i32>>`
     /// }; // without the `.boxed()`, the compiler would not allow this
     /// ```
     fn boxed(self) -> Box<dyn SignalVec<Item = Self::Item>>
@@ -3471,16 +3527,25 @@ pub trait SignalVecExt: SignalVec {
     /// use bevy_ecs::prelude::*;
     /// use jonmo::prelude::*;
     ///
-    /// SignalBuilder::from_system(|_: In<()>| true)
-    /// .switch_signal_vec(|In(condition): In<bool>| {
-    ///     if condition {
-    ///         MutableVec::from([1, 2, 3]).signal_vec().map_in(|x: i32| x * 2).boxed_clone() // this is a `Map<Source<i32>>`
-    ///     } else {
-    ///         MutableVec::from([1, 2, 3]).signal_vec().filter(|In(x): In<i32>| x % 2 == 0).boxed_clone() // this is a `Filter<Source<i32>>`
-    ///     } // without the `.boxed_clone()`, the compiler would not allow this
-    /// });
+    /// SignalBuilder::from_system(|_: In<()>| true).switch_signal_vec(
+    ///     |In(condition): In<bool>, world: &mut World| {
+    ///         if condition {
+    ///             MutableVecBuilder::from([1, 2, 3])
+    ///                 .spawn(world)
+    ///                 .signal_vec()
+    ///                 .map_in(|x: i32| x * 2)
+    ///                 .boxed_clone() // this is a `Map<Source<i32>>`
+    ///         } else {
+    ///             MutableVecBuilder::from([1, 2, 3])
+    ///                 .spawn(world)
+    ///                 .signal_vec()
+    ///                 .filter(|In(x): In<i32>| x % 2 == 0)
+    ///                 .boxed_clone() // this is a `Filter<Source<i32>>`
+    ///         } // without the `.boxed_clone()`, the compiler would not allow this
+    ///     },
+    /// );
     /// ```
-    fn boxed_clone(self) -> Box<dyn SignalVecClone<Item = Self::Item> + Send + Sync>
+    fn boxed_clone(self) -> Box<dyn SignalVecDynClone<Item = Self::Item> + Send + Sync>
     where
         Self: Sized + Clone,
     {
@@ -3500,14 +3565,11 @@ pub trait SignalVecExt: SignalVec {
 impl<T: ?Sized> SignalVecExt for T where T: SignalVec {}
 
 /// Provides immutable access to the underlying [`Vec`].
-pub struct MutableVecReadGuard<'a, T> {
-    guard: RwLockReadGuard<'a, MutableVecState<T>>,
+pub struct MutableVecReadGuard<'s, T> {
+    guard: &'s MutableVecData<T>,
 }
 
-impl<'a, T> Deref for MutableVecReadGuard<'a, T>
-where
-    T: Clone,
-{
+impl<'s, T> Deref for MutableVecReadGuard<'s, T> {
     type Target = [T];
 
     fn deref(&self) -> &Self::Target {
@@ -3516,8 +3578,16 @@ where
 }
 
 /// Provides limited mutable access to the underlying [`Vec`].
-pub struct MutableVecWriteGuard<'a, T> {
-    guard: RwLockWriteGuard<'a, MutableVecState<T>>,
+pub struct MutableVecWriteGuard<'s, T> {
+    guard: Mut<'s, MutableVecData<T>>,
+}
+
+impl<'s, T> Deref for MutableVecWriteGuard<'s, T> {
+    type Target = [T];
+
+    fn deref(&self) -> &Self::Target {
+        &self.guard.vec
+    }
 }
 
 impl<'a, T> MutableVecWriteGuard<'a, T>
@@ -3616,146 +3686,70 @@ where
     pub fn replace<A>(&mut self, values: A)
     where
         Vec<T>: From<A>,
-        A: Clone,
     {
-        self.guard.vec = values.clone().into();
-        self.guard
-            .pending_diffs
-            .push(VecDiff::Replace { values: values.into() });
+        let values: Vec<T> = values.into();
+        self.guard.vec = values.clone();
+        self.guard.pending_diffs.push(VecDiff::Replace { values });
     }
 }
 
-impl<'a, T> Deref for MutableVecWriteGuard<'a, T>
-where
-    T: Clone,
-{
-    type Target = [T];
-
-    fn deref(&self) -> &Self::Target {
-        &self.guard.vec
-    }
-}
+static STALE_MUTABLE_VECS: LazyLock<Mutex<Vec<Entity>>> = LazyLock::new(Mutex::default);
 
-struct MutableVecState<T> {
+/// [`Component`] that holds the actual state for a [`MutableVec`].
+#[derive(Component)]
+pub struct MutableVecData<T> {
     vec: Vec<T>,
     pending_diffs: Vec<VecDiff<T>>,
-    signal: Option<LazySignal>,
+    broadcaster: LazySignal,
 }
 
-/// Wrapper around a [`Vec`] that tracks mutations as [`VecDiff`]s and emits them on
-/// [`.flush`](MutableVec::flush), enabling diff-less constant-time reactive updates for downstream
-/// [`SignalVec`]s.
-#[derive(Clone)]
+/// Wrapper around a [`Vec`] that emits mutations as [`VecDiff`]s, enabling diff-less constant-time
+/// reactive updates for downstream [`SignalVec`]s.
 pub struct MutableVec<T> {
-    state: Arc<RwLock<MutableVecState<T>>>,
+    entity: Entity,
+    references: Arc<AtomicUsize>,
+    _marker: PhantomData<fn() -> T>,
 }
 
-#[derive(Component)]
-pub(crate) struct QueuedVecDiffs<T>(pub(crate) Vec<VecDiff<T>>);
-
-impl<T: Clone> Clone for QueuedVecDiffs<T> {
+impl<T> Clone for MutableVec<T> {
     fn clone(&self) -> Self {
-        Self(self.0.clone())
-    }
-}
-
-impl<T, A> From<T> for MutableVec<A>
-where
-    Vec<A>: From<T>,
-{
-    fn from(values: T) -> Self {
-        MutableVec {
-            state: Arc::new(RwLock::new(MutableVecState {
-                vec: values.into(),
-                pending_diffs: Vec::new(),
-                signal: None,
-            })),
+        self.references.fetch_add(1, core::sync::atomic::Ordering::SeqCst);
+        Self {
+            entity: self.entity,
+            references: self.references.clone(),
+            _marker: PhantomData,
         }
     }
 }
 
-pub(crate) trait Replayable {
-    fn trigger(self) -> Box<dyn FnOnce(&mut World) + Send + Sync>;
-}
-
-#[derive(Component)]
-pub(crate) struct VecReplayTrigger(Box<dyn FnOnce(&mut World) + Send + Sync>);
-
-impl Replayable for VecReplayTrigger {
-    fn trigger(self) -> Box<dyn FnOnce(&mut World) + Send + Sync> {
-        self.0
+impl<T> Drop for MutableVec<T> {
+    fn drop(&mut self) {
+        if self.references.fetch_sub(1, core::sync::atomic::Ordering::SeqCst) == 1 {
+            STALE_MUTABLE_VECS.lock().unwrap().push(self.entity);
+        }
     }
 }
 
 impl<T> MutableVec<T> {
-    /// Constructs a new, empty [`MutableVec<T>`].
-    #[allow(clippy::new_without_default)]
-    pub fn new() -> Self {
-        Self {
-            state: Arc::new(RwLock::new(MutableVecState {
-                vec: Vec::new(),
-                pending_diffs: Vec::new(),
-                signal: None,
-            })),
-        }
-    }
-
-    /// Locks this [`MutableVec`] with shared read access, blocking the current thread until it can
-    /// be acquired, see [`RwLock::read`].
-    pub fn read(&self) -> MutableVecReadGuard<'_, T> {
+    /// Provides read-only access to the underlying [`Vec`] via either a `&World` or a
+    /// `&Query<MutableVecData<T>>`.
+    pub fn read<'s>(&self, mutable_vec_data_reader: impl ReadMutableVecData<'s, T>) -> MutableVecReadGuard<'s, T>
+    where
+        T: SSs,
+    {
         MutableVecReadGuard {
-            guard: self.state.read().unwrap(),
-        }
-    }
-
-    /// Locks this [`MutableVec`] with exclusive write access, blocking the current thread until it
-    /// can be acquired, see [`RwLock::write`].
-    pub fn write(&self) -> MutableVecWriteGuard<'_, T> {
-        MutableVecWriteGuard {
-            guard: self.state.write().unwrap(),
+            guard: mutable_vec_data_reader.read(self.entity),
         }
     }
-
-    fn get_or_create_broadcaster_signal(&self) -> LazySignal
+    /// Provides write access to the underlying [`Vec`] via either a `&mut World` or a
+    /// `&mut Query<&mut MutableVecData<T>>`.
+    pub fn write<'w>(&self, mutable_vec_data_writer: impl WriteMutableVecData<'w, T>) -> MutableVecWriteGuard<'w, T>
     where
-        T: Clone + SSs,
+        T: SSs,
     {
-        let mut state = self.state.write().unwrap();
-
-        // If the signal already exists, just clone and return it.
-        if let Some(lazy_signal) = &state.signal {
-            return lazy_signal.clone();
+        MutableVecWriteGuard {
+            guard: mutable_vec_data_writer.write(self.entity),
         }
-
-        // Otherwise, create the broadcaster signal for the first time.
-        let broadcaster_lazy_signal = LazySignal::new(move |world: &mut World| {
-            let self_entity = LazyEntity::new();
-
-            // This is the system for the one-and-only broadcaster. It just drains diffs that `flush` has put
-            // into its component.
-            let source_system_logic = clone!((self_entity) move |_: In<()>, world: &mut World| {
-                if let Some(mut diffs) = world.get_mut::<QueuedVecDiffs<T>>(self_entity.get()) {
-                    if diffs.0.is_empty() {
-                        None
-                    } else {
-                        Some(diffs.0.drain(..).collect())
-                    }
-                } else {
-                    None
-                }
-            });
-            let signal_system = register_signal::<(), Vec<VecDiff<T>>, _, _, _>(world, source_system_logic);
-            self_entity.set(*signal_system);
-
-            // The broadcaster itself does not have an initial state to replay. It just needs the component to
-            // receive flushed diffs.
-            world.entity_mut(*signal_system).insert(QueuedVecDiffs::<T>(vec![]));
-            signal_system
-        });
-
-        // Store it for future calls.
-        state.signal = Some(broadcaster_lazy_signal.clone());
-        broadcaster_lazy_signal
     }
 
     /// Returns a [`Source`] signal from this [`MutableVec`].
@@ -3763,116 +3757,254 @@ impl<T> MutableVec<T> {
     where
         T: Clone + SSs,
     {
-        let broadcaster_signal = self.get_or_create_broadcaster_signal();
-        let replay_lazy_signal = LazySignal::new(clone!((self.state => state) move | world: & mut World | {
-            let self_entity = LazyEntity::new();
-            let broadcaster_system = broadcaster_signal.register(world);
-
-            // This system has two modes tracked by its `has_run` Local state:
-            //
-            // 1. First run: It ignores upstream diffs and processes its own QueuedVecDiffs (the initial state).
-            //
-            // 2. Subsequent runs: It processes diffs from the upstream broadcaster.
-            let replay_system_logic =
-                clone!(
-                    (self_entity) move | In(upstream_diffs): In<Vec<VecDiff<T>>>,
-                    world: & mut World,
-                    mut has_run: Local < bool >| {
-                        if !*has_run {
-                            // First run is triggered manually. Process the initial state queued on this
-                            // system's entity.
-                            *has_run = true;
-                            let initial_diffs =
-                                world
-                                    .get_entity_mut(self_entity.get())
-                                    .ok()
-                                    .and_then(|mut entity| entity.take::<QueuedVecDiffs<T>>())
-                                    .map(|queued| queued.0)
-                                    .unwrap_or_default();
-                            if initial_diffs.is_empty() {
-                                None
-                            } else {
-                                Some(initial_diffs)
-                            }
-                        } else {
-                            // Subsequent runs are triggered by the broadcaster. Process upstream diffs.
-                            if upstream_diffs.is_empty() {
-                                None
-                            } else {
-                                Some(upstream_diffs)
-                            }
-                        }
+        let replay_lazy_signal = LazySignal::new(clone!((self => self_) move |world: &mut World| {
+            let broadcaster_system = world.get::<MutableVecData<T>>(self_.entity).unwrap().broadcaster.clone().register(world);
+
+            let replay_system_logic = clone!((self_) move |In(upstream_diffs): In<Vec<VecDiff<T>>>, world: &mut World, mut has_run: Local<bool>| {
+                if !*has_run {
+                    *has_run = true;
+                    let initial_vec = self_.read(&*world).to_vec();
+                    if !initial_vec.is_empty() {
+                        Some(vec![VecDiff::Replace { values: initial_vec }])
+                    } else {
+                        None
                     }
-                );
+                } else if upstream_diffs.is_empty() { None } else { Some(upstream_diffs) }
+            });
 
-            // 1. Register the replay system.
             let replay_signal = register_signal::<_, Vec<VecDiff<T>>, _, _, _>(world, replay_system_logic);
-            self_entity.set(*replay_signal);
 
-            // The trigger now unconditionally pokes the replay system with an empty input.
-            // The replay system's own logic will handle whether it's the first run or not.
             let trigger = Box::new(move |world: &mut World| {
                 process_signals(world, [replay_signal], Box::new(Vec::<VecDiff<T>>::new()));
             });
 
-            // 2. Queue the initial state for this new subscriber.
-            let initial_vec = state.read().unwrap().vec.clone();
-            let initial_diffs = if !initial_vec.is_empty() {
-                vec![VecDiff::Replace { values: initial_vec }]
-            } else {
-                vec![]
-            };
-            world.entity_mut(*replay_signal).insert((QueuedVecDiffs(initial_diffs), VecReplayTrigger(trigger)));
+            let mut replay_entity = world.entity_mut(*replay_signal);
+            replay_entity.insert(VecReplayTrigger(trigger));
 
-            // 3. Pipe the broadcaster to the replay node.
             pipe_signal(world, broadcaster_system, replay_signal);
             replay_signal
         }));
+
         Source {
             signal: replay_lazy_signal,
             _marker: PhantomData,
         }
     }
+}
 
-    /// Emits any pending [`VecDiff`]s to downstream [`SignalVec`]s.
-    pub fn flush_into_world(&self, world: &mut World)
-    where
-        T: SSs,
-    {
-        let mut state = self.state.write().unwrap();
-        if state.pending_diffs.is_empty() {
-            return;
-        }
-        let signal = if let Some(lazy_signal) = &state.signal
-            && let LazySystem::Registered(signal_system) = *lazy_signal.inner.system.read().unwrap()
-        {
-            signal_system
-        } else {
-            return;
+pub(crate) fn despawn_stale_mutable_vecs(world: &mut World) {
+    let mut queue = STALE_MUTABLE_VECS.lock().unwrap();
+    for entity in queue.drain(..) {
+        world.despawn(entity);
+    }
+}
+
+fn new_mutable_vec_data<T>(values: Vec<T>) -> (MutableVecData<T>, LazyEntity)
+where
+    T: Clone + SSs,
+{
+    let data_entity = LazyEntity::new();
+    let broadcaster = LazySignal::new(clone!((data_entity) move |world: &mut World| {
+        let source_system = move |_: In<()>, mut mutable_vec_datas: Query<&mut MutableVecData<T>>| {
+            let mut data = mutable_vec_datas.get_mut(*data_entity).unwrap();
+                if data.pending_diffs.is_empty() {
+                    None
+                } else {
+                    Some(core::mem::take(&mut data.pending_diffs))
+                }
         };
-        if let Ok(mut entity) = world.get_entity_mut(*signal)
-            && let Some(mut queued_diffs) = entity.get_mut::<QueuedVecDiffs<T>>()
+
+        register_signal::<(), Vec<VecDiff<T>>, _, _, _>(world, source_system)
+    }));
+    (
+        MutableVecData {
+            vec: values,
+            pending_diffs: Vec::new(),
+            broadcaster,
+        },
+        data_entity,
+    )
+}
+
+impl<T> From<&mut World> for MutableVec<T>
+where
+    T: Clone + SSs,
+{
+    fn from(world: &mut World) -> Self {
+        let (data, data_entity) = new_mutable_vec_data::<T>(Vec::new());
+        let entity = world.spawn(data).id();
+        data_entity.set(entity);
+        Self {
+            entity,
+            references: Arc::new(AtomicUsize::new(1)),
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<T> FromWorld for MutableVec<T>
+where
+    T: Clone + SSs,
+{
+    fn from_world(world: &mut World) -> Self {
+        world.into()
+    }
+}
+
+/// Builder for constructing a [`MutableVec`] with initial values, e.g. `MutableVecBuilder::from([0,
+/// 1, 2]).spawn(&mut World)`.
+pub struct MutableVecBuilder<T>(Vec<T>);
+
+impl<T, A> From<A> for MutableVecBuilder<T>
+where
+    Vec<T>: From<A>,
+{
+    fn from(value: A) -> Self {
+        Self(value.into())
+    }
+}
+
+impl<T: SSs + Clone> MutableVecBuilder<T> {
+    /// Spawns a [`MutableVec`] using a `&mut World`.
+    pub fn spawn(self, world: &mut World) -> MutableVec<T> {
+        let (data, data_entity) = new_mutable_vec_data::<T>(self.0);
+        let entity = world.spawn(data).id();
+        data_entity.set(entity);
+        MutableVec {
+            entity,
+            references: Arc::new(AtomicUsize::new(1)),
+            _marker: PhantomData,
+        }
+    }
+
+    /// Spawns a [`MutableVec`] using a `&mut Commands`.
+    pub fn spawnc(self, commands: &mut Commands) -> MutableVec<T> {
+        let (data, data_entity) = new_mutable_vec_data::<T>(self.0);
+        let entity = commands.spawn(data).id();
+        data_entity.set(entity);
+        MutableVec {
+            entity,
+            references: Arc::new(AtomicUsize::new(1)),
+            _marker: PhantomData,
+        }
+    }
+}
+
+impl<T> From<&mut Commands<'_, '_>> for MutableVec<T>
+where
+    T: Clone + SSs,
+{
+    fn from(commands: &mut Commands) -> Self {
+        let (data, data_entity) = new_mutable_vec_data::<T>(Vec::new());
+        let entity = commands.spawn(data).id();
+        data_entity.set(entity);
+        Self {
+            entity,
+            references: Arc::new(AtomicUsize::new(1)),
+            _marker: PhantomData,
+        }
+    }
+}
+
+#[derive(Component)]
+pub(crate) struct QueuedVecDiffs<T>(pub(crate) Vec<VecDiff<T>>);
+
+impl<T: Clone> Clone for QueuedVecDiffs<T> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+
+pub(crate) trait Replayable {
+    fn trigger(self) -> Box<dyn FnOnce(&mut World) + Send + Sync>;
+}
+
+#[derive(Component)]
+pub(crate) struct VecReplayTrigger(Box<dyn FnOnce(&mut World) + Send + Sync>);
+
+impl Replayable for VecReplayTrigger {
+    fn trigger(self) -> Box<dyn FnOnce(&mut World) + Send + Sync> {
+        self.0
+    }
+}
+
+pub(crate) fn trigger_replays<ReplayTrigger: Component + Replayable>(world: &mut World) {
+    let triggers: Vec<Entity> = world
+        .query_filtered::<Entity, With<ReplayTrigger>>()
+        .iter(world)
+        .collect();
+    for trigger_entity in triggers {
+        if let Some(trigger_component) = world
+            .get_entity_mut(trigger_entity)
+            .ok()
+            .and_then(|mut e| e.take::<ReplayTrigger>())
         {
-            queued_diffs.0.append(&mut state.pending_diffs);
+            trigger_component.trigger()(world);
         }
     }
+}
 
-    /// Returns an `impl Command` that can be passed to [`Commands::queue`] to flush this
-    /// [`MutableVec`]'s pending [`VecDiff`]s, see [`.flush_into_world`](Self::flush_into_world).
-    pub fn flush(&self) -> impl Command
-    where
-        T: Clone + SSs,
-    {
-        let self_ = self.clone();
-        move |world: &mut World| self_.flush_into_world(world)
+/// Specifies mutation accessors for [`MutableVec`]s.
+pub trait ReadMutableVecData<'s, T>
+where
+    T: Send + Sync,
+{
+    #[allow(missing_docs)]
+    fn read(self, entity: Entity) -> &'s MutableVecData<T>;
+}
+
+impl<'s, T> ReadMutableVecData<'s, T> for &'s Query<'_, 's, &MutableVecData<T>>
+where
+    T: SSs,
+{
+    fn read(self, entity: Entity) -> &'s MutableVecData<T> {
+        self.get(entity).unwrap()
+    }
+}
+
+impl<'s, T> ReadMutableVecData<'s, T> for &'s World
+where
+    T: SSs,
+{
+    fn read(self, entity: Entity) -> &'s MutableVecData<T> {
+        self.get(entity).unwrap()
+    }
+}
+
+/// Specifies mutation accessors for [`MutableVec`]s.
+pub trait WriteMutableVecData<'w, T>
+where
+    T: Send + Sync,
+{
+    #[allow(missing_docs)]
+    fn write(self, entity: Entity) -> Mut<'w, MutableVecData<T>>;
+}
+
+impl<'a, 'w, 's, T> WriteMutableVecData<'a, T> for &'a mut Query<'w, 's, &mut MutableVecData<T>>
+where
+    T: SSs,
+{
+    fn write(self, entity: Entity) -> Mut<'a, MutableVecData<T>> {
+        self.get_mut(entity).unwrap()
+    }
+}
+
+impl<'w, T> WriteMutableVecData<'w, T> for &'w mut World
+where
+    T: SSs,
+{
+    fn write(self, entity: Entity) -> Mut<'w, MutableVecData<T>> {
+        self.get_mut(entity).unwrap()
     }
 }
 
 #[cfg(test)]
-mod tests {
+pub(crate) mod tests {
     use super::*;
     use crate::JonmoPlugin;
     use bevy::prelude::*;
+    use bevy_platform::sync::RwLock;
+    use test_log::test;
 
     #[derive(Resource, Default, Debug)]
     struct SignalVecOutput<T: Clone + fmt::Debug>(Vec<VecDiff<T>>);
@@ -3895,10 +4027,6 @@ mod tests {
         output.0.extend(diffs);
     }
 
-    fn get_signal_vec_output<T: SSs + Clone + fmt::Debug>(world: &World) -> Vec<VecDiff<T>> {
-        world.resource::<SignalVecOutput<T>>().0.clone()
-    }
-
     // Helper to make assertions cleaner
     fn get_and_clear_output<T: SSs + Clone + fmt::Debug>(world: &mut World) -> Vec<VecDiff<T>> {
         let output = world.resource::<SignalVecOutput<T>>().0.clone();
@@ -3951,7 +4079,7 @@ mod tests {
     }
 
     // Helper function to apply a series of diffs to a vector to check the final state.
-    fn apply_diffs<T: Clone>(initial: &mut Vec<T>, diffs: &[VecDiff<T>]) {
+    fn apply_diffs<T: Clone>(initial: &mut Vec<T>, diffs: Vec<VecDiff<T>>) {
         for diff in diffs {
             diff.apply_to_vec(initial);
         }
@@ -3973,651 +4101,648 @@ mod tests {
             .and_then(|mut res| res.0.take())
     }
 
+    pub(crate) fn cleanup(maps_too: bool) {
+        STALE_MUTABLE_VECS.lock().unwrap().clear();
+        if maps_too {
+            crate::signal_map::tests::cleanup(false);
+        }
+    }
+
     #[test]
     fn test_for_each() {
-        // A comprehensive test for `SignalVecExt::for_each`. This test verifies that
-        // the combinator correctly receives a batch of `VecDiff`s and transforms the
-        // `SignalVec` into a standard `Signal`.
+        {
+            // A comprehensive test for `SignalVecExt::for_each`. This test verifies that
+            // the combinator correctly receives a batch of `VecDiff`s and transforms the
+            // `SignalVec` into a standard `Signal`.
+
+            // --- 1. Setup ---
+            let mut app = create_test_app();
+
+            // The output of our `for_each` system will be the full, reconstructed vector.
+            app.init_resource::<FinalSignalOutput<Vec<String>>>();
+            let source_vec = MutableVecBuilder::from(["a".to_string(), "b".to_string()]).spawn(app.world_mut());
+
+            // This system reconstructs the state of the vec by applying the diffs it
+            // receives. It then outputs the complete, current state. This allows us to
+            // verify that `for_each` receives the diffs correctly and transforms the stream.
+            let reconstructor_system = |In(diffs): In<Vec<VecDiff<String>>>, mut state: Local<Vec<String>>| {
+                // Only emit an output if there were actual changes.
+                if diffs.is_empty() {
+                    return None;
+                }
+                for diff in diffs {
+                    diff.apply_to_vec(&mut state);
+                }
+                // Output the new, complete state.
+                Some(state.clone())
+            };
 
-        // --- 1. Setup ---
-        let mut app = create_test_app();
+            let handle = source_vec
+                .signal_vec()
+                .for_each(reconstructor_system)
+                .map(capture_final_output::<Vec<String>>)
+                .register(app.world_mut());
 
-        // The output of our `for_each` system will be the full, reconstructed vector.
-        app.init_resource::<FinalSignalOutput<Vec<String>>>();
-        let source_vec = MutableVec::from(vec!["a".to_string(), "b".to_string()]);
-
-        // This system reconstructs the state of the vec by applying the diffs it
-        // receives. It then outputs the complete, current state. This allows us to
-        // verify that `for_each` receives the diffs correctly and transforms the stream.
-        let reconstructor_system = |In(diffs): In<Vec<VecDiff<String>>>, mut state: Local<Vec<String>>| {
-            // Only emit an output if there were actual changes.
-            if diffs.is_empty() {
-                return None;
-            }
-            for diff in diffs {
-                diff.apply_to_vec(&mut state);
+            // --- 2. Test Initial State ---
+            // The initial `Replace` diff should be received and processed.
+            app.update();
+            let expected_initial_state = vec!["a".to_string(), "b".to_string()];
+            assert_eq!(
+                get_and_clear_final_output::<Vec<String>>(app.world_mut()),
+                Some(expected_initial_state),
+                "Initial state was not reconstructed correctly by for_each"
+            );
+
+            // --- 3. Test Batched Mutations ---
+            // Perform multiple operations before flushing to test batch processing.
+            {
+                let mut writer = source_vec.write(app.world_mut());
+                writer.push("c".to_string()); // source: ["a", "b", "c"]
+                writer.set(0, "A".to_string()); // source: ["A", "b", "c"]
+                writer.remove(1); // source: ["A", "c"]
             }
-            // Output the new, complete state.
-            Some(state.clone())
-        };
+            app.update();
+            let expected_batched_state = vec!["A".to_string(), "c".to_string()];
+            assert_eq!(
+                get_and_clear_final_output::<Vec<String>>(app.world_mut()),
+                Some(expected_batched_state),
+                "State after batched mutations was not reconstructed correctly"
+            );
 
-        let handle = source_vec
-            .signal_vec()
-            .for_each(reconstructor_system)
-            .map(capture_final_output::<Vec<String>>)
-            .register(app.world_mut());
+            // --- 4. Test No-Op Frame ---
+            // If the source doesn't flush, the `for_each` system should not run,
+            // and the output signal should not emit a new value.
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<Vec<String>>(app.world_mut()),
+                None,
+                "Signal emitted on a no-op frame"
+            );
 
-        // --- 2. Test Initial State ---
-        // The initial `Replace` diff should be received and processed.
-        app.update();
-        let expected_initial_state = vec!["a".to_string(), "b".to_string()];
-        assert_eq!(
-            get_and_clear_final_output::<Vec<String>>(app.world_mut()),
-            Some(expected_initial_state),
-            "Initial state was not reconstructed correctly by for_each"
-        );
+            // --- 5. Test Clear Operation ---
+            // The `Clear` diff should result in an empty vector.
+            source_vec.write(app.world_mut()).clear();
+            app.update();
+            let expected_cleared_state: Vec<String> = Vec::new();
+            assert_eq!(
+                get_and_clear_final_output::<Vec<String>>(app.world_mut()),
+                Some(expected_cleared_state),
+                "State after Clear was not reconstructed correctly"
+            );
 
-        // --- 3. Test Batched Mutations ---
-        // Perform multiple operations before flushing to test batch processing.
-        {
-            let mut writer = source_vec.write();
-            writer.push("c".to_string()); // source: ["a", "b", "c"]
-            writer.set(0, "A".to_string()); // source: ["A", "b", "c"]
-            writer.remove(1); // source: ["A", "c"]
+            // --- 6. Cleanup ---
+            handle.cleanup(app.world_mut());
         }
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let expected_batched_state = vec!["A".to_string(), "c".to_string()];
-        assert_eq!(
-            get_and_clear_final_output::<Vec<String>>(app.world_mut()),
-            Some(expected_batched_state),
-            "State after batched mutations was not reconstructed correctly"
-        );
 
-        // --- 4. Test No-Op Frame ---
-        // If the source doesn't flush, the `for_each` system should not run,
-        // and the output signal should not emit a new value.
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<Vec<String>>(app.world_mut()),
-            None,
-            "Signal emitted on a no-op frame"
-        );
-
-        // --- 5. Test Clear Operation ---
-        // The `Clear` diff should result in an empty vector.
-        source_vec.write().clear();
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let expected_cleared_state: Vec<String> = Vec::new();
-        assert_eq!(
-            get_and_clear_final_output::<Vec<String>>(app.world_mut()),
-            Some(expected_cleared_state),
-            "State after Clear was not reconstructed correctly"
-        );
-
-        // --- 6. Cleanup ---
-        handle.cleanup(app.world_mut());
-    }
+        cleanup(true)
+    }
 
     #[test]
     fn test_map() {
-        // A comprehensive test for `SignalVecExt::map`, covering all `VecDiff`
-        // types in both success and system-failure scenarios.
-
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-
-        // The output `SignalVec` will contain `String`s.
-        app.init_resource::<SignalVecOutput<String>>();
-
-        // The source vector that we will mutate.
-        let source_vec = MutableVec::from(vec![1, 10]);
-
-        // Define a resource that the mapping system will depend on. This allows us to
-        // test system failure by removing the resource.
-        #[derive(Resource)]
-        struct MapFactor(String);
+        {
+            // A comprehensive test for `SignalVecExt::map`, covering all `VecDiff`
+            // types in both success and system-failure scenarios.
 
-        // The mapping system: appends a factor from the resource to the number.
-        let mapping_system = |In(val): In<i32>, factor: Res<MapFactor>| format!("{}{}", val, factor.0);
+            // --- 1. Setup ---
+            let mut app = create_test_app();
 
-        // The signal chain under test.
-        let mapped_signal = source_vec.signal_vec().map(mapping_system);
+            // The output `SignalVec` will contain `String`s.
+            app.init_resource::<SignalVecOutput<String>>();
 
-        // Register the final signal to a system that captures its output diffs.
-        let handle = mapped_signal
-            .for_each(capture_signal_vec_output)
-            .register(app.world_mut());
+            // The source vector that we will mutate.
+            let source_vec = MutableVecBuilder::from([1, 10]).spawn(app.world_mut());
 
-        // A local copy of the mapped vector's state to verify against.
-        let mut current_state: Vec<String> = vec![];
+            // Define a resource that the mapping system will depend on. This allows us to
+            // test system failure by removing the resource.
+            #[derive(Resource)]
+            struct MapFactor(String);
 
-        // --- 2. Test Success Scenarios ---
-        // First, test all diff types when the mapping system is guaranteed to succeed.
-        app.insert_resource(MapFactor("x".to_string()));
+            // The mapping system: appends a factor from the resource to the number.
+            let mapping_system = |In(val): In<i32>, factor: Res<MapFactor>| format!("{}{}", val, factor.0);
 
-        // Test: Initial `Replace`
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Initial update should produce one Replace diff.");
-        assert_eq!(
-            diffs[0],
-            VecDiff::Replace {
-                values: vec!["1x".to_string(), "10x".to_string()]
-            },
-            "Initial `Replace` was incorrect."
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec!["1x".to_string(), "10x".to_string()]);
+            // The signal chain under test.
+            let mapped_signal = source_vec.signal_vec().map(mapping_system);
 
-        // Test: `Push`
-        source_vec.write().push(4);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(
-            diffs[0],
-            VecDiff::Push {
-                value: "4x".to_string()
-            }
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            vec!["1x".to_string(), "10x".to_string(), "4x".to_string()]
-        );
+            // Register the final signal to a system that captures its output diffs.
+            let handle = mapped_signal
+                .for_each(capture_signal_vec_output)
+                .register(app.world_mut());
 
-        // Test: `InsertAt`
-        source_vec.write().insert(1, 5);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(
-            diffs[0],
-            VecDiff::InsertAt {
-                index: 1,
-                value: "5x".to_string()
-            }
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            vec!["1x".to_string(), "5x".to_string(), "10x".to_string(), "4x".to_string()]
-        );
+            // A local copy of the mapped vector's state to verify against.
+            let mut current_state: Vec<String> = vec![];
 
-        // Test: `UpdateAt`
-        source_vec.write().set(0, 99);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(
-            diffs[0],
-            VecDiff::UpdateAt {
-                index: 0,
-                value: "99x".to_string()
-            }
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            vec!["99x".to_string(), "5x".to_string(), "10x".to_string(), "4x".to_string()]
-        );
+            // --- 2. Test Success Scenarios ---
+            // First, test all diff types when the mapping system is guaranteed to succeed.
+            app.insert_resource(MapFactor("x".to_string()));
 
-        // Test: `RemoveAt` (passes through without mapping)
-        source_vec.write().remove(2); // removes 10
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(diffs[0], VecDiff::RemoveAt { index: 2 });
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            vec!["99x".to_string(), "5x".to_string(), "4x".to_string()]
-        );
+            // Test: Initial `Replace`
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Initial update should produce one Replace diff.");
+            assert_eq!(
+                diffs[0],
+                VecDiff::Replace {
+                    values: vec!["1x".to_string(), "10x".to_string()]
+                },
+                "Initial `Replace` was incorrect."
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec!["1x".to_string(), "10x".to_string()]);
+
+            // Test: `Push`
+            source_vec.write(app.world_mut()).push(4);
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(
+                diffs[0],
+                VecDiff::Push {
+                    value: "4x".to_string()
+                }
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec!["1x".to_string(), "10x".to_string(), "4x".to_string()]
+            );
 
-        // Test: `Pop` (passes through without mapping)
-        source_vec.write().pop(); // removes 4
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(diffs[0], VecDiff::Pop);
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec!["99x".to_string(), "5x".to_string()]);
-
-        // Test: `Move` (passes through without mapping)
-        source_vec.write().move_item(1, 0); // moves 5 to front
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(
-            diffs[0],
-            VecDiff::Move {
-                old_index: 1,
-                new_index: 0
-            }
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec!["5x".to_string(), "99x".to_string()]);
+            // Test: `InsertAt`
+            source_vec.write(app.world_mut()).insert(1, 5);
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(
+                diffs[0],
+                VecDiff::InsertAt {
+                    index: 1,
+                    value: "5x".to_string()
+                }
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec!["1x".to_string(), "5x".to_string(), "10x".to_string(), "4x".to_string()]
+            );
 
-        // Test: `Clear` (passes through without mapping)
-        source_vec.write().clear();
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(diffs[0], VecDiff::Clear);
-        apply_diffs(&mut current_state, &diffs);
-        assert!(current_state.is_empty());
-
-        // --- 3. Test System Failure Scenarios ---
-        // Now, remove the resource to cause the mapping system to fail.
-        app.world_mut().remove_resource::<MapFactor>();
-
-        // Test: `Push` with failing system.
-        // The `run_system_with(...).ok()` will return `None`, so the item is dropped.
-        source_vec.write().push(88);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert!(
-            diffs.is_empty(),
-            "Pushing with a failing system should produce no diff."
-        );
-        assert!(current_state.is_empty(), "State should remain empty.");
+            // Test: `UpdateAt`
+            source_vec.write(app.world_mut()).set(0, 99);
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(
+                diffs[0],
+                VecDiff::UpdateAt {
+                    index: 0,
+                    value: "99x".to_string()
+                }
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec!["99x".to_string(), "5x".to_string(), "10x".to_string(), "4x".to_string()]
+            );
 
-        // Test: `Replace` with failing system.
-        // `map` will filter_map over the values, and all will fail. The output should be
-        // a `Replace` diff with an empty vector.
-        source_vec.write().replace(vec![1, 2, 3]);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Replace with a failing system should produce one diff.");
-        assert_eq!(
-            diffs[0],
-            VecDiff::Replace { values: vec![] },
-            "Replace with failing system should result in an empty vector."
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert!(current_state.is_empty());
+            // Test: `RemoveAt` (passes through without mapping)
+            source_vec.write(app.world_mut()).remove(2); // removes 10
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(diffs[0], VecDiff::RemoveAt { index: 2 });
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec!["99x".to_string(), "5x".to_string(), "4x".to_string()]
+            );
 
-        // --- 4. Test System Recovery ---
-        // Re-introduce the resource. The system should now succeed again.
-        app.insert_resource(MapFactor("y".to_string()));
+            // Test: `Pop` (passes through without mapping)
+            source_vec.write(app.world_mut()).pop(); // removes 4
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(diffs[0], VecDiff::Pop);
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec!["99x".to_string(), "5x".to_string()]);
+
+            // Test: `Move` (passes through without mapping)
+            source_vec.write(app.world_mut()).move_item(1, 0); // moves 5 to front
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(
+                diffs[0],
+                VecDiff::Move {
+                    old_index: 1,
+                    new_index: 0
+                }
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec!["5x".to_string(), "99x".to_string()]);
+
+            // Test: `Clear` (passes through without mapping)
+            source_vec.write(app.world_mut()).clear();
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(diffs[0], VecDiff::Clear);
+            apply_diffs(&mut current_state, diffs);
+            assert!(current_state.is_empty());
+
+            // --- 3. Test System Failure Scenarios ---
+            // Now, remove the resource to cause the mapping system to fail.
+            app.world_mut().remove_resource::<MapFactor>();
+
+            // Test: `Push` with failing system.
+            // The `run_system_with(...).ok()` will return `None`, so the item is dropped.
+            source_vec.write(app.world_mut()).push(88);
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert!(
+                diffs.is_empty(),
+                "Pushing with a failing system should produce no diff."
+            );
+            assert!(current_state.is_empty(), "State should remain empty.");
+
+            // Test: `Replace` with failing system.
+            // `map` will filter_map over the values, and all will fail. The output should be
+            // a `Replace` diff with an empty vector.
+            source_vec.write(app.world_mut()).replace(vec![1, 2, 3]);
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Replace with a failing system should produce one diff.");
+            assert_eq!(
+                diffs[0],
+                VecDiff::Replace { values: vec![] },
+                "Replace with failing system should result in an empty vector."
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert!(current_state.is_empty());
+
+            // --- 4. Test System Recovery ---
+            // Re-introduce the resource. The system should now succeed again.
+            app.insert_resource(MapFactor("y".to_string()));
+
+            // Test: `Push` after recovery. The source vec is [1, 2, 3] from the last
+            // replace. Now we push 7. The `map` only processes the `Push` diff.
+            source_vec.write(app.world_mut()).push(7);
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Push after recovery should produce one diff.");
+            assert_eq!(
+                diffs[0],
+                VecDiff::Push {
+                    value: "7y".to_string()
+                }
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec!["7y".to_string()],
+                "State should only contain the newly pushed item after recovery."
+            );
 
-        // Test: `Push` after recovery. The source vec is [1, 2, 3] from the last
-        // replace. Now we push 7. The `map` only processes the `Push` diff.
-        source_vec.write().push(7);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Push after recovery should produce one diff.");
-        assert_eq!(
-            diffs[0],
-            VecDiff::Push {
-                value: "7y".to_string()
-            }
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            vec!["7y".to_string()],
-            "State should only contain the newly pushed item after recovery."
-        );
+            // --- 5. Cleanup ---
+            handle.cleanup(app.world_mut());
+        }
 
-        // --- 5. Cleanup ---
-        handle.cleanup(app.world_mut());
+        cleanup(true)
     }
 
     #[test]
     fn test_map_in() {
-        // A comprehensive test for `SignalVecExt::map_in`, covering all `VecDiff`
-        // types and verifying it correctly uses state captured by the closure.
+        {
+            // A comprehensive test for `SignalVecExt::map_in`, covering all `VecDiff`
+            // types and verifying it correctly uses state captured by the closure.
 
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-        app.init_resource::<SignalVecOutput<String>>();
+            // --- 1. Setup ---
+            let mut app = create_test_app();
+            app.init_resource::<SignalVecOutput<String>>();
 
-        let source_vec = MutableVec::from(vec![1, 10, 100]);
+            let source_vec = MutableVecBuilder::from([1, 10, 100]).spawn(app.world_mut());
 
-        // A variable to be captured by the `map_in` closure.
-        // We'll use this to demonstrate that the closure's captured state is respected
-        // and can change over time.
-        let mapping_factor = Arc::new(RwLock::new("a".to_string()));
+            // A variable to be captured by the `map_in` closure.
+            // We'll use this to demonstrate that the closure's captured state is respected
+            // and can change over time.
+            let mapping_factor = Arc::new(RwLock::new("a".to_string()));
 
-        // The signal chain under test, using `map_in` with a `move` closure.
-        let mapped_signal = source_vec.signal_vec().map_in(clone!((mapping_factor) move |val: i32| {
-            let factor = mapping_factor.read().unwrap();
-            format!("{}{}", val, *factor)
-        }));
+            // The signal chain under test, using `map_in` with a `move` closure.
+            let mapped_signal = source_vec.signal_vec().map_in(clone!((mapping_factor) move |val: i32| {
+                let factor = mapping_factor.read().unwrap();
+                format!("{}{}", val, *factor)
+            }));
 
-        let handle = mapped_signal
-            .for_each(capture_signal_vec_output)
-            .register(app.world_mut());
+            let handle = mapped_signal
+                .for_each(capture_signal_vec_output)
+                .register(app.world_mut());
 
-        // A local copy of the mapped vector's state to verify against.
-        let mut current_state: Vec<String> = vec![];
+            // A local copy of the mapped vector's state to verify against.
+            let mut current_state: Vec<String> = vec![];
 
-        // --- 2. Test Scenarios ---
+            // --- 2. Test Scenarios ---
 
-        // Test: Initial `Replace`
-        // The first update should replay the initial state of the source vector,
-        // mapped with the initial factor "a".
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Initial update should produce one Replace diff.");
-        assert_eq!(
-            diffs[0],
-            VecDiff::Replace {
-                values: vec!["1a".to_string(), "10a".to_string(), "100a".to_string()]
-            },
-            "Initial `Replace` was incorrect."
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            vec!["1a".to_string(), "10a".to_string(), "100a".to_string()]
-        );
+            // Test: Initial `Replace`
+            // The first update should replay the initial state of the source vector,
+            // mapped with the initial factor "a".
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Initial update should produce one Replace diff.");
+            assert_eq!(
+                diffs[0],
+                VecDiff::Replace {
+                    values: vec!["1a".to_string(), "10a".to_string(), "100a".to_string()]
+                },
+                "Initial `Replace` was incorrect."
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec!["1a".to_string(), "10a".to_string(), "100a".to_string()]
+            );
 
-        // --- Change the captured state ---
-        // Modify the captured factor. Subsequent mapping operations should use this
-        // new value.
-        *mapping_factor.write().unwrap() = "b".to_string();
+            // --- Change the captured state ---
+            // Modify the captured factor. Subsequent mapping operations should use this
+            // new value.
+            *mapping_factor.write().unwrap() = "b".to_string();
 
-        // Test: `Push` using the new factor "b"
-        source_vec.write().push(4);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(
-            diffs[0],
-            VecDiff::Push {
-                value: "4b".to_string()
-            }
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            vec![
-                "1a".to_string(),
-                "10a".to_string(),
-                "100a".to_string(),
-                "4b".to_string()
-            ]
-        );
+            // Test: `Push` using the new factor "b"
+            source_vec.write(app.world_mut()).push(4);
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(
+                diffs[0],
+                VecDiff::Push {
+                    value: "4b".to_string()
+                }
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec![
+                    "1a".to_string(),
+                    "10a".to_string(),
+                    "100a".to_string(),
+                    "4b".to_string()
+                ]
+            );
 
-        // Test: `InsertAt` using the new factor "b"
-        source_vec.write().insert(1, 5);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(
-            diffs[0],
-            VecDiff::InsertAt {
-                index: 1,
-                value: "5b".to_string()
-            }
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            vec![
-                "1a".to_string(),
-                "5b".to_string(),
-                "10a".to_string(),
-                "100a".to_string(),
-                "4b".to_string()
-            ]
-        );
+            // Test: `InsertAt` using the new factor "b"
+            source_vec.write(app.world_mut()).insert(1, 5);
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(
+                diffs[0],
+                VecDiff::InsertAt {
+                    index: 1,
+                    value: "5b".to_string()
+                }
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec![
+                    "1a".to_string(),
+                    "5b".to_string(),
+                    "10a".to_string(),
+                    "100a".to_string(),
+                    "4b".to_string()
+                ]
+            );
 
-        // Test: `UpdateAt` using the new factor "b"
-        source_vec.write().set(0, 99);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(
-            diffs[0],
-            VecDiff::UpdateAt {
-                index: 0,
-                value: "99b".to_string()
-            }
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            vec![
-                "99b".to_string(),
-                "5b".to_string(),
-                "10a".to_string(),
-                "100a".to_string(),
-                "4b".to_string()
-            ]
-        );
+            // Test: `UpdateAt` using the new factor "b"
+            source_vec.write(app.world_mut()).set(0, 99);
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(
+                diffs[0],
+                VecDiff::UpdateAt {
+                    index: 0,
+                    value: "99b".to_string()
+                }
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec![
+                    "99b".to_string(),
+                    "5b".to_string(),
+                    "10a".to_string(),
+                    "100a".to_string(),
+                    "4b".to_string()
+                ]
+            );
 
-        // --- Test pass-through diffs ---
-        // These diffs don't involve mapping values, so they are simply forwarded.
+            // --- Test pass-through diffs ---
+            // These diffs don't involve mapping values, so they are simply forwarded.
 
-        // Test: `RemoveAt`
-        source_vec.write().remove(2); // removes 10
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(diffs[0], VecDiff::RemoveAt { index: 2 });
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            vec![
-                "99b".to_string(),
-                "5b".to_string(),
-                "100a".to_string(),
-                "4b".to_string()
-            ]
-        );
+            // Test: `RemoveAt`
+            source_vec.write(app.world_mut()).remove(2); // removes 10
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(diffs[0], VecDiff::RemoveAt { index: 2 });
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec![
+                    "99b".to_string(),
+                    "5b".to_string(),
+                    "100a".to_string(),
+                    "4b".to_string()
+                ]
+            );
 
-        // Test: `Pop`
-        source_vec.write().pop(); // removes 4
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(diffs[0], VecDiff::Pop);
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            vec!["99b".to_string(), "5b".to_string(), "100a".to_string()]
-        );
+            // Test: `Pop`
+            source_vec.write(app.world_mut()).pop(); // removes 4
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(diffs[0], VecDiff::Pop);
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec!["99b".to_string(), "5b".to_string(), "100a".to_string()]
+            );
 
-        // Test: `Move`
-        source_vec.write().move_item(1, 0); // moves 5 to front
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(
-            diffs[0],
-            VecDiff::Move {
-                old_index: 1,
-                new_index: 0
-            }
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            vec!["5b".to_string(), "99b".to_string(), "100a".to_string()]
-        );
+            // Test: `Move`
+            source_vec.write(app.world_mut()).move_item(1, 0); // moves 5 to front
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(
+                diffs[0],
+                VecDiff::Move {
+                    old_index: 1,
+                    new_index: 0
+                }
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec!["5b".to_string(), "99b".to_string(), "100a".to_string()]
+            );
 
-        // Test: `Clear`
-        source_vec.write().clear();
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(diffs[0], VecDiff::Clear);
-        apply_diffs(&mut current_state, &diffs);
-        assert!(current_state.is_empty());
+            // Test: `Clear`
+            source_vec.write(app.world_mut()).clear();
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(diffs[0], VecDiff::Clear);
+            apply_diffs(&mut current_state, diffs);
+            assert!(current_state.is_empty());
+
+            // --- 3. Cleanup ---
+            handle.cleanup(app.world_mut());
+        }
 
-        // --- 3. Cleanup ---
-        handle.cleanup(app.world_mut());
+        cleanup(true)
     }
 
     #[test]
     fn test_map_in_ref() {
-        // A comprehensive test for `SignalVecExt::map_in_ref`, covering all `VecDiff`
-        // types and verifying it correctly uses a closure that takes a reference.
+        {
+            // A comprehensive test for `SignalVecExt::map_in_ref`, covering all `VecDiff`
+            // types and verifying it correctly uses a closure that takes a reference.
 
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-        app.init_resource::<SignalVecOutput<String>>();
+            // --- 1. Setup ---
+            let mut app = create_test_app();
+            app.init_resource::<SignalVecOutput<String>>();
 
-        // The source vector contains integers.
-        let source_vec = MutableVec::from(vec![10, 20]);
+            // The source vector contains integers.
+            let source_vec = MutableVecBuilder::from([10, 20]).spawn(app.world_mut());
 
-        // The signal chain under test, using `map_in_ref` with a function pointer
-        // that operates on a reference (`&i32`). This is an idiomatic use case.
-        let mapped_signal = source_vec.signal_vec().map_in_ref(ToString::to_string);
+            // The signal chain under test, using `map_in_ref` with a function pointer
+            // that operates on a reference (`&i32`). This is an idiomatic use case.
+            let mapped_signal = source_vec.signal_vec().map_in_ref(ToString::to_string);
 
-        let handle = mapped_signal
-            .for_each(capture_signal_vec_output)
-            .register(app.world_mut());
+            let handle = mapped_signal
+                .for_each(capture_signal_vec_output)
+                .register(app.world_mut());
 
-        // A local copy of the mapped vector's state to verify against.
-        let mut current_state: Vec<String> = vec![];
+            // A local copy of the mapped vector's state to verify against.
+            let mut current_state: Vec<String> = vec![];
 
-        // --- 2. Test Scenarios ---
+            // --- 2. Test Scenarios ---
 
-        // Test: Initial `Replace`
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Initial update should produce one Replace diff.");
-        assert_eq!(
-            diffs[0],
-            VecDiff::Replace {
-                values: vec!["10".to_string(), "20".to_string()]
-            },
-            "Initial `Replace` was incorrect."
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec!["10".to_string(), "20".to_string()]);
+            // Test: Initial `Replace`
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Initial update should produce one Replace diff.");
+            assert_eq!(
+                diffs[0],
+                VecDiff::Replace {
+                    values: vec!["10".to_string(), "20".to_string()]
+                },
+                "Initial `Replace` was incorrect."
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec!["10".to_string(), "20".to_string()]);
+
+            // Test: `Push`
+            source_vec.write(app.world_mut()).push(30);
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(
+                diffs[0],
+                VecDiff::Push {
+                    value: "30".to_string()
+                }
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec!["10".to_string(), "20".to_string(), "30".to_string()]
+            );
 
-        // Test: `Push`
-        source_vec.write().push(30);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(
-            diffs[0],
-            VecDiff::Push {
-                value: "30".to_string()
-            }
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            vec!["10".to_string(), "20".to_string(), "30".to_string()]
-        );
+            // Test: `InsertAt`
+            source_vec.write(app.world_mut()).insert(1, 5);
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(
+                diffs[0],
+                VecDiff::InsertAt {
+                    index: 1,
+                    value: "5".to_string()
+                }
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec!["10".to_string(), "5".to_string(), "20".to_string(), "30".to_string()]
+            );
 
-        // Test: `InsertAt`
-        source_vec.write().insert(1, 5);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(
-            diffs[0],
-            VecDiff::InsertAt {
-                index: 1,
-                value: "5".to_string()
-            }
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            vec!["10".to_string(), "5".to_string(), "20".to_string(), "30".to_string()]
-        );
+            // Test: `UpdateAt`
+            source_vec.write(app.world_mut()).set(0, 99);
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(
+                diffs[0],
+                VecDiff::UpdateAt {
+                    index: 0,
+                    value: "99".to_string()
+                }
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec!["99".to_string(), "5".to_string(), "20".to_string(), "30".to_string()]
+            );
 
-        // Test: `UpdateAt`
-        source_vec.write().set(0, 99);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(
-            diffs[0],
-            VecDiff::UpdateAt {
-                index: 0,
-                value: "99".to_string()
-            }
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            vec!["99".to_string(), "5".to_string(), "20".to_string(), "30".to_string()]
-        );
+            // --- Test pass-through diffs ---
+            // These diffs don't involve mapping values, so they are simply forwarded.
+
+            // Test: `RemoveAt`
+            source_vec.write(app.world_mut()).remove(2); // removes 20
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(diffs[0], VecDiff::RemoveAt { index: 2 });
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec!["99".to_string(), "5".to_string(), "30".to_string()]);
+
+            // Test: `Pop`
+            source_vec.write(app.world_mut()).pop(); // removes 30
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(diffs[0], VecDiff::Pop);
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec!["99".to_string(), "5".to_string()]);
+
+            // Test: `Move`
+            source_vec.write(app.world_mut()).move_item(1, 0); // moves 5 to front
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(
+                diffs[0],
+                VecDiff::Move {
+                    old_index: 1,
+                    new_index: 0
+                }
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec!["5".to_string(), "99".to_string()]);
+
+            // Test: `Clear`
+            source_vec.write(app.world_mut()).clear();
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(diffs[0], VecDiff::Clear);
+            apply_diffs(&mut current_state, diffs);
+            assert!(current_state.is_empty());
+
+            // --- 3. Cleanup ---
+            handle.cleanup(app.world_mut());
+        }
 
-        // --- Test pass-through diffs ---
-        // These diffs don't involve mapping values, so they are simply forwarded.
-
-        // Test: `RemoveAt`
-        source_vec.write().remove(2); // removes 20
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(diffs[0], VecDiff::RemoveAt { index: 2 });
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec!["99".to_string(), "5".to_string(), "30".to_string()]);
-
-        // Test: `Pop`
-        source_vec.write().pop(); // removes 30
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(diffs[0], VecDiff::Pop);
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec!["99".to_string(), "5".to_string()]);
-
-        // Test: `Move`
-        source_vec.write().move_item(1, 0); // moves 5 to front
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(
-            diffs[0],
-            VecDiff::Move {
-                old_index: 1,
-                new_index: 0
-            }
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec!["5".to_string(), "99".to_string()]);
-
-        // Test: `Clear`
-        source_vec.write().clear();
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(diffs[0], VecDiff::Clear);
-        apply_diffs(&mut current_state, &diffs);
-        assert!(current_state.is_empty());
-
-        // --- 3. Cleanup ---
-        handle.cleanup(app.world_mut());
-    }
+        cleanup(true)
+    }
 
     /// This test provides comprehensive coverage for `SignalVecExt::map_signal`.
     ///
@@ -4643,459 +4768,450 @@ mod tests {
     ///    updates from the old, now-orphaned inner signal are no longer propagated.
     #[test]
     fn test_map_signal() {
-        let mut app = create_test_app();
-        app.init_resource::<SignalVecOutput<Name>>();
-
-        // Setup: Create entities with `Name` components that our signals will track.
-        let entity_a = app.world_mut().spawn(Name::new("Alice")).id();
-        let entity_b = app.world_mut().spawn(Name::new("Bob")).id();
-
-        // The source vec contains entities. The goal is to create a derived vec that
-        // contains the _names_ of these entities.
-        let entity_vec = MutableVec::from([entity_a, entity_b]);
-
-        // This "factory" system takes an entity and creates a signal that tracks its
-        // `Name`.
-        let factory_system = |In(entity): In<Entity>| SignalBuilder::from_component::<Name>(entity).dedupe();
-
-        // Apply `map_signal` to transform the SignalVec`<Entity>` into a
-        // SignalVec`<Name>`.
-        let name_vec_signal = entity_vec.signal_vec().map_signal(factory_system);
-        let handle = name_vec_signal
-            .for_each(capture_signal_vec_output)
-            .register(app.world_mut());
-
-        // Test 1: Initial State.
-        app.update();
-        let diffs = get_and_clear_output::<Name>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Initial state should produce one Replace diff");
-        assert_eq!(
-            diffs[0],
-            VecDiff::Replace {
-                values: vec![Name::new("Alice"), Name::new("Bob")]
-            },
-            "Initial state is incorrect"
-        );
-
-        // Test 2: Inner Signal Update.
-        *app.world_mut().get_mut::<Name>(entity_a).unwrap() = Name::new("Alicia");
-        app.update();
-        let diffs = get_and_clear_output::<Name>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Name change should produce one Update diff");
-        assert_eq!(
-            diffs[0],
-            VecDiff::UpdateAt {
-                index: 0,
-                value: Name::new("Alicia"),
-            },
-            "Update diff is incorrect"
-        );
-
-        // Test 3: No change should produce no diff.
-        app.update();
-        let diffs = get_and_clear_output::<Name>(app.world_mut());
-        assert!(diffs.is_empty(), "No change should produce no diffs");
-
-        // Test 4: Source SignalVec Push.
-        let entity_c = app.world_mut().spawn(Name::new("Charlie")).id();
-        entity_vec.write().push(entity_c);
-        entity_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<Name>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Push should produce one diff");
-        assert_eq!(
-            diffs[0],
-            VecDiff::Push {
-                value: Name::new("Charlie")
-            },
-            "Push diff is incorrect"
-        );
-
-        // Test 5: Source SignalVec InsertAt.
-        let entity_d = app.world_mut().spawn(Name::new("David")).id();
-        entity_vec.write().insert(1, entity_d);
-        entity_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<Name>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "InsertAt should produce one diff");
-        assert_eq!(
-            diffs[0],
-            VecDiff::InsertAt {
-                index: 1,
-                value: Name::new("David"),
-            },
-            "InsertAt diff is incorrect"
-        );
+        {
+            let mut app = create_test_app();
+            app.init_resource::<SignalVecOutput<Name>>();
+
+            // Setup: Create entities with `Name` components that our signals will track.
+            let entity_a = app.world_mut().spawn(Name::new("Alice")).id();
+            let entity_b = app.world_mut().spawn(Name::new("Bob")).id();
+
+            // The source vec contains entities. The goal is to create a derived vec that
+            // contains the _names_ of these entities.
+            let entity_vec = MutableVecBuilder::from([entity_a, entity_b]).spawn(app.world_mut());
+
+            // This "factory" system takes an entity and creates a signal that tracks its
+            // `Name`.
+            let factory_system = |In(entity): In<Entity>| SignalBuilder::from_component::<Name>(entity).dedupe();
+
+            // Apply `map_signal` to transform the SignalVec`<Entity>` into a
+            // SignalVec`<Name>`.
+            let name_vec_signal = entity_vec.signal_vec().map_signal(factory_system);
+            let handle = name_vec_signal
+                .for_each(capture_signal_vec_output)
+                .register(app.world_mut());
+
+            // Test 1: Initial State.
+            app.update();
+            let diffs = get_and_clear_output::<Name>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Initial state should produce one Replace diff");
+            assert_eq!(
+                diffs[0],
+                VecDiff::Replace {
+                    values: vec![Name::new("Alice"), Name::new("Bob")]
+                },
+                "Initial state is incorrect"
+            );
 
-        // Test 6: Source SignalVec RemoveAt. Remove Bob
-        entity_vec.write().remove(2);
-        entity_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<Name>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "RemoveAt should produce one diff");
-        assert_eq!(diffs[0], VecDiff::RemoveAt { index: 2 }, "RemoveAt diff is incorrect");
+            // Test 2: Inner Signal Update.
+            *app.world_mut().get_mut::<Name>(entity_a).unwrap() = Name::new("Alicia");
+            app.update();
+            let diffs = get_and_clear_output::<Name>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Name change should produce one Update diff");
+            assert_eq!(
+                diffs[0],
+                VecDiff::UpdateAt {
+                    index: 0,
+                    value: Name::new("Alicia"),
+                },
+                "Update diff is incorrect"
+            );
 
-        // Verify cleanup by ensuring updates to the removed entity's signal are ignored.
-        *app.world_mut().get_mut::<Name>(entity_b).unwrap() = Name::new("Robert");
-        app.update();
-        let diffs = get_and_clear_output::<Name>(app.world_mut());
-        assert!(diffs.is_empty(), "Update on removed entity should not produce a diff");
+            // Test 3: No change should produce no diff.
+            app.update();
+            let diffs = get_and_clear_output::<Name>(app.world_mut());
+            assert!(diffs.is_empty(), "No change should produce no diffs");
+
+            // Test 4: Source SignalVec Push.
+            let entity_c = app.world_mut().spawn(Name::new("Charlie")).id();
+            entity_vec.write(app.world_mut()).push(entity_c);
+            app.update();
+            let diffs = get_and_clear_output::<Name>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Push should produce one diff");
+            assert_eq!(
+                diffs[0],
+                VecDiff::Push {
+                    value: Name::new("Charlie")
+                },
+                "Push diff is incorrect"
+            );
 
-        // Test 7: Source SignalVec UpdateAt (switching the underlying signal).
-        let entity_e = app.world_mut().spawn(Name::new("Eve")).id();
+            // Test 5: Source SignalVec InsertAt.
+            let entity_d = app.world_mut().spawn(Name::new("David")).id();
+            entity_vec.write(app.world_mut()).insert(1, entity_d);
+            app.update();
+            let diffs = get_and_clear_output::<Name>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "InsertAt should produce one diff");
+            assert_eq!(
+                diffs[0],
+                VecDiff::InsertAt {
+                    index: 1,
+                    value: Name::new("David"),
+                },
+                "InsertAt diff is incorrect"
+            );
 
-        // Replace Alicia with Eve
-        entity_vec.write().set(0, entity_e);
-        entity_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<Name>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Set/UpdateAt should produce one diff");
-        assert_eq!(
-            diffs[0],
-            VecDiff::UpdateAt {
-                index: 0,
-                value: Name::new("Eve"),
-            },
-            "Update-to-new-entity diff is incorrect"
-        );
+            // Test 6: Source SignalVec RemoveAt. Remove Bob
+            entity_vec.write(app.world_mut()).remove(2);
+            app.update();
+            let diffs = get_and_clear_output::<Name>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "RemoveAt should produce one diff");
+            assert_eq!(diffs[0], VecDiff::RemoveAt { index: 2 }, "RemoveAt diff is incorrect");
+
+            // Verify cleanup by ensuring updates to the removed entity's signal are ignored.
+            *app.world_mut().get_mut::<Name>(entity_b).unwrap() = Name::new("Robert");
+            app.update();
+            let diffs = get_and_clear_output::<Name>(app.world_mut());
+            assert!(diffs.is_empty(), "Update on removed entity should not produce a diff");
+
+            // Test 7: Source SignalVec UpdateAt (switching the underlying signal).
+            let entity_e = app.world_mut().spawn(Name::new("Eve")).id();
+
+            // Replace Alicia with Eve
+            entity_vec.write(app.world_mut()).set(0, entity_e);
+            app.update();
+            let diffs = get_and_clear_output::<Name>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Set/UpdateAt should produce one diff");
+            assert_eq!(
+                diffs[0],
+                VecDiff::UpdateAt {
+                    index: 0,
+                    value: Name::new("Eve"),
+                },
+                "Update-to-new-entity diff is incorrect"
+            );
 
-        // Verify cleanup of old signal
-        *app.world_mut().get_mut::<Name>(entity_a).unwrap() = Name::new("Alicia_v2");
-        app.update();
-        let diffs = get_and_clear_output::<Name>(app.world_mut());
-        assert!(
-            diffs.is_empty(),
-            "Update on old, replaced entity should not produce a diff"
-        );
+            // Verify cleanup of old signal
+            *app.world_mut().get_mut::<Name>(entity_a).unwrap() = Name::new("Alicia_v2");
+            app.update();
+            let diffs = get_and_clear_output::<Name>(app.world_mut());
+            assert!(
+                diffs.is_empty(),
+                "Update on old, replaced entity should not produce a diff"
+            );
 
-        // Verify new signal is active
-        *app.world_mut().get_mut::<Name>(entity_e).unwrap() = Name::new("Evelyn");
-        app.update();
-        let diffs = get_and_clear_output::<Name>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Update on new entity should produce a diff");
-        assert_eq!(
-            diffs[0],
-            VecDiff::UpdateAt {
-                index: 0,
-                value: Name::new("Evelyn"),
-            },
-            "Update on new entity is incorrect"
-        );
+            // Verify new signal is active
+            *app.world_mut().get_mut::<Name>(entity_e).unwrap() = Name::new("Evelyn");
+            app.update();
+            let diffs = get_and_clear_output::<Name>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Update on new entity should produce a diff");
+            assert_eq!(
+                diffs[0],
+                VecDiff::UpdateAt {
+                    index: 0,
+                    value: Name::new("Evelyn"),
+                },
+                "Update on new entity is incorrect"
+            );
 
-        // Test 8: Source SignalVec Move. Move Charlie to front
-        entity_vec.write().move_item(2, 0);
-        entity_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<Name>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Move should produce one diff");
-        assert_eq!(
-            diffs[0],
-            VecDiff::Move {
-                old_index: 2,
-                new_index: 0,
-            },
-            "Move diff is incorrect"
-        );
+            // Test 8: Source SignalVec Move. Move Charlie to front
+            entity_vec.write(app.world_mut()).move_item(2, 0);
+            app.update();
+            let diffs = get_and_clear_output::<Name>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Move should produce one diff");
+            assert_eq!(
+                diffs[0],
+                VecDiff::Move {
+                    old_index: 2,
+                    new_index: 0,
+                },
+                "Move diff is incorrect"
+            );
 
-        // Verify tracking of moved item
-        *app.world_mut().get_mut::<Name>(entity_c).unwrap() = Name::new("Charles");
-        app.update();
-        let diffs = get_and_clear_output::<Name>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Update on moved entity should produce a diff");
-        assert_eq!(
-            diffs[0],
-            VecDiff::UpdateAt {
-                index: 0,
-                value: Name::new("Charles"),
-            },
-            "Update on moved entity is incorrect"
-        );
+            // Verify tracking of moved item
+            *app.world_mut().get_mut::<Name>(entity_c).unwrap() = Name::new("Charles");
+            app.update();
+            let diffs = get_and_clear_output::<Name>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Update on moved entity should produce a diff");
+            assert_eq!(
+                diffs[0],
+                VecDiff::UpdateAt {
+                    index: 0,
+                    value: Name::new("Charles"),
+                },
+                "Update on moved entity is incorrect"
+            );
 
-        // Test 9: Source SignalVec Pop. Removes David
-        entity_vec.write().pop();
-        entity_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<Name>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Pop should produce one diff");
-        assert_eq!(diffs[0], VecDiff::Pop, "Pop diff is incorrect");
+            // Test 9: Source SignalVec Pop. Removes David
+            entity_vec.write(app.world_mut()).pop();
+            app.update();
+            let diffs = get_and_clear_output::<Name>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Pop should produce one diff");
+            assert_eq!(diffs[0], VecDiff::Pop, "Pop diff is incorrect");
+
+            // Test 10: Source SignalVec Clear.
+            entity_vec.write(app.world_mut()).clear();
+            app.update();
+            let diffs = get_and_clear_output::<Name>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Clear should produce one diff");
+            assert_eq!(diffs[0], VecDiff::Clear, "Clear diff is incorrect");
+            assert!(entity_vec.read(app.world()).is_empty());
+            handle.cleanup(app.world_mut());
+        }
 
-        // Test 10: Source SignalVec Clear.
-        entity_vec.write().clear();
-        entity_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<Name>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Clear should produce one diff");
-        assert_eq!(diffs[0], VecDiff::Clear, "Clear diff is incorrect");
-        assert!(entity_vec.read().is_empty());
-        handle.cleanup(app.world_mut());
+        cleanup(true)
     }
 
     #[test]
     fn test_filter() {
-        // A comprehensive test for `SignalVecExt::filter`, covering all `VecDiff`
-        // types and edge cases like items changing their filter status.
-
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-        app.init_resource::<SignalVecOutput<i32>>();
-
-        // The source vector contains a mix of values to be filtered.
-        let source_vec = MutableVec::from(vec![1, 2, 3, 4]);
-
-        // The filter predicate: only allow even numbers.
-        let is_even = |In(x): In<i32>| x % 2 == 0;
+        {
+            // A comprehensive test for `SignalVecExt::filter`, covering all `VecDiff`
+            // types and edge cases like items changing their filter status.
 
-        // The signal chain under test.
-        let filtered_signal = source_vec.signal_vec().filter(is_even);
+            // --- 1. Setup ---
+            let mut app = create_test_app();
+            app.init_resource::<SignalVecOutput<i32>>();
 
-        let handle = filtered_signal
-            .for_each(capture_signal_vec_output)
-            .register(app.world_mut());
+            // The source vector contains a mix of values to be filtered.
+            let source_vec = MutableVecBuilder::from([1, 2, 3, 4]).spawn(app.world_mut());
 
-        // A local copy of the filtered vector's state to verify against.
-        let mut current_state: Vec<i32> = vec![];
+            // The filter predicate: only allow even numbers.
+            let is_even = |In(x): In<i32>| x % 2 == 0;
 
-        // --- 2. Test Initial State (`Replace`) ---
-        app.update();
-        let diffs = get_and_clear_output::<i32>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Initial update should produce one Replace diff.");
-        assert_eq!(
-            diffs[0],
-            VecDiff::Replace { values: vec![2, 4] },
-            "Initial `Replace` did not filter correctly."
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec![2, 4]);
+            // The signal chain under test.
+            let filtered_signal = source_vec.signal_vec().filter(is_even);
 
-        // --- 3. Test `Push` ---
-        // Push a value that passes the filter (6).
-        source_vec.write().push(6);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<i32>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(diffs[0], VecDiff::Push { value: 6 });
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec![2, 4, 6]);
-
-        // Push a value that fails the filter (7).
-        source_vec.write().push(7);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<i32>(app.world_mut());
-        assert!(diffs.is_empty(), "Pushing a filtered-out value should produce no diff.");
-        assert_eq!(current_state, vec![2, 4, 6]); // State should be unchanged.
-
-        // --- 4. Test `UpdateAt` (Status Change) ---
-        // Update an item from filtered-out to included (3 -> 8).
-        // Source is [1, 2, 3, 4, 6, 7]. Update index 2.
-        // It should be inserted into the output at index 1 (after 2).
-        source_vec.write().set(2, 8);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<i32>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(
-            diffs[0],
-            VecDiff::InsertAt { index: 1, value: 8 },
-            "Update from filtered to included failed"
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec![2, 8, 4, 6]);
-
-        // Update an item from included to filtered-out (4 -> 9).
-        // Source is now [1, 2, 8, 4, 6, 7]. Update index 3.
-        // It should be removed from the output at index 2 (where 4 was).
-        source_vec.write().set(3, 9);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<i32>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(
-            diffs[0],
-            VecDiff::RemoveAt { index: 2 },
-            "Update from included to filtered failed"
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec![2, 8, 6]);
+            let handle = filtered_signal
+                .for_each(capture_signal_vec_output)
+                .register(app.world_mut());
 
-        // --- 5. Test `RemoveAt` ---
-        // Remove an included item (2) from the source at index 1.
-        source_vec.write().remove(1);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<i32>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(diffs[0], VecDiff::RemoveAt { index: 0 }); // It was at the start of the output
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec![8, 6]);
-
-        // --- 6. Test `Move` ---
-        // Source is now [1, 8, 9, 6, 7]. Filtered is [8, 6].
-        // Move 8 (source index 1) to after 6 (source index 3).
-        // Source becomes [1, 9, 6, 8, 7].
-        // This should move index 0 (value 8) to index 1 in the output.
-        source_vec.write().move_item(1, 3);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<i32>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(
-            diffs[0],
-            VecDiff::Move {
-                old_index: 0,
-                new_index: 1
-            }
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec![6, 8]);
+            // A local copy of the filtered vector's state to verify against.
+            let mut current_state: Vec<i32> = vec![];
 
-        // --- 7. Test `Clear` ---
-        source_vec.write().clear();
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<i32>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(diffs[0], VecDiff::Clear);
-        apply_diffs(&mut current_state, &diffs);
-        assert!(current_state.is_empty());
+            // --- 2. Test Initial State (`Replace`) ---
+            app.update();
+            let diffs = get_and_clear_output::<i32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Initial update should produce one Replace diff.");
+            assert_eq!(
+                diffs[0],
+                VecDiff::Replace { values: vec![2, 4] },
+                "Initial `Replace` did not filter correctly."
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![2, 4]);
+
+            // --- 3. Test `Push` ---
+            // Push a value that passes the filter (6).
+            source_vec.write(app.world_mut()).push(6);
+            app.update();
+            let diffs = get_and_clear_output::<i32>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(diffs[0], VecDiff::Push { value: 6 });
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![2, 4, 6]);
+
+            // Push a value that fails the filter (7).
+            source_vec.write(app.world_mut()).push(7);
+            app.update();
+            let diffs = get_and_clear_output::<i32>(app.world_mut());
+            assert!(diffs.is_empty(), "Pushing a filtered-out value should produce no diff.");
+            assert_eq!(current_state, vec![2, 4, 6]); // State should be unchanged.
+
+            // --- 4. Test `UpdateAt` (Status Change) ---
+            // Update an item from filtered-out to included (3 -> 8).
+            // Source is [1, 2, 3, 4, 6, 7]. Update index 2.
+            // It should be inserted into the output at index 1 (after 2).
+            source_vec.write(app.world_mut()).set(2, 8);
+            app.update();
+            let diffs = get_and_clear_output::<i32>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(
+                diffs[0],
+                VecDiff::InsertAt { index: 1, value: 8 },
+                "Update from filtered to included failed"
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![2, 8, 4, 6]);
+
+            // Update an item from included to filtered-out (4 -> 9).
+            // Source is now [1, 2, 8, 4, 6, 7]. Update index 3.
+            // It should be removed from the output at index 2 (where 4 was).
+            source_vec.write(app.world_mut()).set(3, 9);
+            app.update();
+            let diffs = get_and_clear_output::<i32>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(
+                diffs[0],
+                VecDiff::RemoveAt { index: 2 },
+                "Update from included to filtered failed"
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![2, 8, 6]);
+
+            // --- 5. Test `RemoveAt` ---
+            // Remove an included item (2) from the source at index 1.
+            source_vec.write(app.world_mut()).remove(1);
+            app.update();
+            let diffs = get_and_clear_output::<i32>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(diffs[0], VecDiff::RemoveAt { index: 0 }); // It was at the start of the output
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![8, 6]);
+
+            // --- 6. Test `Move` ---
+            // Source is now [1, 8, 9, 6, 7]. Filtered is [8, 6].
+            // Move 8 (source index 1) to after 6 (source index 3).
+            // Source becomes [1, 9, 6, 8, 7].
+            // This should move index 0 (value 8) to index 1 in the output.
+            source_vec.write(app.world_mut()).move_item(1, 3);
+            app.update();
+            let diffs = get_and_clear_output::<i32>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(
+                diffs[0],
+                VecDiff::Move {
+                    old_index: 0,
+                    new_index: 1
+                }
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![6, 8]);
+
+            // --- 7. Test `Clear` ---
+            source_vec.write(app.world_mut()).clear();
+            app.update();
+            let diffs = get_and_clear_output::<i32>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(diffs[0], VecDiff::Clear);
+            apply_diffs(&mut current_state, diffs);
+            assert!(current_state.is_empty());
+
+            // --- 8. Cleanup ---
+            handle.cleanup(app.world_mut());
+        }
 
-        // --- 8. Cleanup ---
-        handle.cleanup(app.world_mut());
+        cleanup(true)
     }
 
     #[test]
     fn test_filter_map() {
-        // A comprehensive test for `SignalVecExt::filter_map`, covering all `VecDiff`
-        // types and the three status-change scenarios for `UpdateAt`.
-
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-        app.init_resource::<SignalVecOutput<u32>>();
-
-        // The source vector contains strings, some of which are parsable as numbers.
-        let source_vec = MutableVec::from(vec!["10", "foo", "20", "bar"]);
-
-        // The filter_map predicate: parse strings to u32, returning Some on success
-        // and None on failure.
-        let parse_u32 = |In(s): In<&'static str>| s.parse::<u32>().ok();
+        {
+            // A comprehensive test for `SignalVecExt::filter_map`, covering all `VecDiff`
+            // types and the three status-change scenarios for `UpdateAt`.
 
-        // The signal chain under test.
-        let filtered_mapped_signal = source_vec.signal_vec().filter_map(parse_u32);
+            // --- 1. Setup ---
+            let mut app = create_test_app();
+            app.init_resource::<SignalVecOutput<u32>>();
 
-        let handle = filtered_mapped_signal
-            .for_each(capture_signal_vec_output)
-            .register(app.world_mut());
+            // The source vector contains strings, some of which are parsable as numbers.
+            let source_vec = MutableVecBuilder::from(["10", "foo", "20", "bar"]).spawn(app.world_mut());
 
-        // A local copy of the filtered/mapped vector's state.
-        let mut current_state: Vec<u32> = vec![];
+            // The filter_map predicate: parse strings to u32, returning Some on success
+            // and None on failure.
+            let parse_u32 = |In(s): In<&'static str>| s.parse::<u32>().ok();
 
-        // --- 2. Test Initial State (`Replace`) ---
-        app.update();
-        let diffs = get_and_clear_output::<u32>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Initial update should produce one Replace diff.");
-        assert_eq!(
-            diffs[0],
-            VecDiff::Replace { values: vec![10, 20] },
-            "Initial `Replace` did not filter and map correctly."
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec![10, 20]);
+            // The signal chain under test.
+            let filtered_mapped_signal = source_vec.signal_vec().filter_map(parse_u32);
 
-        // --- 3. Test `Push` ---
-        // Push a value that passes the filter_map ("30").
-        source_vec.write().push("30");
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<u32>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(diffs[0], VecDiff::Push { value: 30 });
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec![10, 20, 30]);
-
-        // Push a value that fails the filter_map ("baz").
-        source_vec.write().push("baz");
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<u32>(app.world_mut());
-        assert!(diffs.is_empty(), "Pushing a filtered-out value should produce no diff.");
+            let handle = filtered_mapped_signal
+                .for_each(capture_signal_vec_output)
+                .register(app.world_mut());
 
-        // --- 4. Test `UpdateAt` Status Changes ---
-        // Case 1: None -> Some (Update "foo" at source index 1 to "40").
-        source_vec.write().set(1, "40");
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<u32>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(diffs[0], VecDiff::InsertAt { index: 1, value: 40 });
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec![10, 40, 20, 30]);
-
-        // Case 2: Some -> None (Update "20" at source index 2 to "qux").
-        source_vec.write().set(2, "qux");
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<u32>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(diffs[0], VecDiff::RemoveAt { index: 2 });
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec![10, 40, 30]);
-
-        // Case 3: Some -> Some (Update "10" at source index 0 to "50").
-        source_vec.write().set(0, "50");
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<u32>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(diffs[0], VecDiff::UpdateAt { index: 0, value: 50 });
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec![50, 40, 30]);
-
-        // --- 5. Test `RemoveAt` ---
-        // Source is now: ["50", "40", "qux", "bar", "30", "baz"]
-        // Filtered is: [50, 40, 30]
-        // Remove "40" from source at index 1. This is at output index 1.
-        source_vec.write().remove(1);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<u32>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(diffs[0], VecDiff::RemoveAt { index: 1 });
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec![50, 30]);
-
-        // --- 6. Test `Move` ---
-        // Source is now: ["50", "qux", "bar", "30", "baz"]
-        // Filtered is: [50, 30]
-        // Move "30" (source index 3) to the front (source index 0).
-        // This moves output index 1 to output index 0.
-        source_vec.write().move_item(3, 0);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<u32>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(
-            diffs[0],
-            VecDiff::Move {
-                old_index: 1,
-                new_index: 0
-            }
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec![30, 50]);
+            // A local copy of the filtered/mapped vector's state.
+            let mut current_state: Vec<u32> = vec![];
 
-        // --- 7. Test `Clear` ---
-        source_vec.write().clear();
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<u32>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(diffs[0], VecDiff::Clear);
-        apply_diffs(&mut current_state, &diffs);
-        assert!(current_state.is_empty());
+            // --- 2. Test Initial State (`Replace`) ---
+            app.update();
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Initial update should produce one Replace diff.");
+            assert_eq!(
+                diffs[0],
+                VecDiff::Replace { values: vec![10, 20] },
+                "Initial `Replace` did not filter and map correctly."
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![10, 20]);
+
+            // --- 3. Test `Push` ---
+            // Push a value that passes the filter_map ("30").
+            source_vec.write(app.world_mut()).push("30");
+            // drop(source_vec)
+            app.update();
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(diffs[0], VecDiff::Push { value: 30 });
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![10, 20, 30]);
+
+            // Push a value that fails the filter_map ("baz").
+            source_vec.write(app.world_mut()).push("baz");
+            app.update();
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            assert!(diffs.is_empty(), "Pushing a filtered-out value should produce no diff.");
+
+            // --- 4. Test `UpdateAt` Status Changes ---
+            // Case 1: None -> Some (Update "foo" at source index 1 to "40").
+            source_vec.write(app.world_mut()).set(1, "40");
+            app.update();
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(diffs[0], VecDiff::InsertAt { index: 1, value: 40 });
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![10, 40, 20, 30]);
+
+            // Case 2: Some -> None (Update "20" at source index 2 to "qux").
+            source_vec.write(app.world_mut()).set(2, "qux");
+            app.update();
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(diffs[0], VecDiff::RemoveAt { index: 2 });
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![10, 40, 30]);
+
+            // Case 3: Some -> Some (Update "10" at source index 0 to "50").
+            source_vec.write(app.world_mut()).set(0, "50");
+            app.update();
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(diffs[0], VecDiff::UpdateAt { index: 0, value: 50 });
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![50, 40, 30]);
+
+            // --- 5. Test `RemoveAt` ---
+            // Source is now: ["50", "40", "qux", "bar", "30", "baz"]
+            // Filtered is: [50, 40, 30]
+            // Remove "40" from source at index 1. This is at output index 1.
+            source_vec.write(app.world_mut()).remove(1);
+            app.update();
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(diffs[0], VecDiff::RemoveAt { index: 1 });
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![50, 30]);
+
+            // --- 6. Test `Move` ---
+            // Source is now: ["50", "qux", "bar", "30", "baz"]
+            // Filtered is: [50, 30]
+            // Move "30" (source index 3) to the front (source index 0).
+            // This moves output index 1 to output index 0.
+            source_vec.write(app.world_mut()).move_item(3, 0);
+            app.update();
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(
+                diffs[0],
+                VecDiff::Move {
+                    old_index: 1,
+                    new_index: 0
+                }
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![30, 50]);
+
+            // --- 7. Test `Clear` ---
+            source_vec.write(app.world_mut()).clear();
+            app.update();
+            let diffs = get_and_clear_output::<u32>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(diffs[0], VecDiff::Clear);
+            apply_diffs(&mut current_state, diffs);
+            assert!(current_state.is_empty());
+
+            // --- 8. Cleanup ---
+            handle.cleanup(app.world_mut());
+        }
 
-        // --- 8. Cleanup ---
-        handle.cleanup(app.world_mut());
+        cleanup(true)
     }
 
     /// This test provides comprehensive coverage for a single
@@ -5114,120 +5230,118 @@ mod tests {
     ///    removed from the filtered list based on their new value.
     #[test]
     fn test_filter_signal() {
-        // A resource to control the filter's behavior.
-        #[derive(Resource, Clone, PartialEq, Debug)]
-        struct FilterMode(bool);
-
-        let mut app = create_test_app();
-        app.init_resource::<SignalVecOutput<i32>>();
-
-        // --- Setup --- Initially, filter for even numbers.
-        app.insert_resource(FilterMode(true));
-        let source_vec = MutableVec::from(vec![1, 2, 3, 4]);
-        let filtered_signal = source_vec.signal_vec().filter_signal(|In(val): In<i32>| {
-            SignalBuilder::from_resource::<FilterMode>().map(move |In(mode): In<FilterMode>| {
-                // even or odd
-                if mode.0 { val % 2 == 0 } else { val % 2 != 0 }
-            })
-        });
-        let handle = filtered_signal
-            .for_each(capture_signal_vec_output)
-            .register(app.world_mut());
-
-        // --- 1. Initial State (Even) ---
-        app.update();
-        let mut current_state = vec![];
-        apply_diffs(&mut current_state, &get_and_clear_output::<i32>(app.world_mut()));
-        assert_eq!(current_state, vec![2, 4], "Initial state (even) is incorrect.");
-
-        // --- 2. Change Filter (to Odd) ---
-        *app.world_mut().resource_mut::<FilterMode>() = FilterMode(false);
-        app.update();
-        apply_diffs(&mut current_state, &get_and_clear_output::<i32>(app.world_mut()));
-        assert_eq!(current_state, vec![1, 3], "State after switching to odd is incorrect.");
-
-        // --- 3. Source Vec Push (respecting Odd filter) --- Push an odd number, should
-        // appear.
-        source_vec.write().push(5);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        apply_diffs(&mut current_state, &get_and_clear_output::<i32>(app.world_mut()));
-        assert_eq!(
-            current_state,
-            vec![1, 3, 5],
-            "State after pushing odd number is incorrect."
-        );
-
-        // Push an even number, should be filtered out.
-        source_vec.write().push(6);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<i32>(app.world_mut());
-        assert!(
-            diffs.is_empty(),
-            "Pushing a filtered-out number should produce no diffs."
-        );
-        assert_eq!(
-            current_state,
-            vec![1, 3, 5],
-            "State should be unchanged after pushing even number."
-        );
-
-        // --- 4. Change Filter (back to Even) ---
-        *app.world_mut().resource_mut::<FilterMode>() = FilterMode(true);
-        app.update();
-        apply_diffs(&mut current_state, &get_and_clear_output::<i32>(app.world_mut()));
+        {
+            // A resource to control the filter's behavior.
+            #[derive(Resource, Clone, PartialEq, Debug)]
+            struct FilterMode(bool);
+
+            let mut app = create_test_app();
+            app.init_resource::<SignalVecOutput<i32>>();
+
+            // --- Setup --- Initially, filter for even numbers.
+            app.insert_resource(FilterMode(true));
+            let source_vec = MutableVecBuilder::from([1, 2, 3, 4]).spawn(app.world_mut());
+            let filtered_signal = source_vec.signal_vec().filter_signal(|In(val): In<i32>| {
+                SignalBuilder::from_resource::<FilterMode>().map(move |In(mode): In<FilterMode>| {
+                    // even or odd
+                    if mode.0 { val % 2 == 0 } else { val % 2 != 0 }
+                })
+            });
+            let handle = filtered_signal
+                .for_each(capture_signal_vec_output)
+                .register(app.world_mut());
+
+            // --- 1. Initial State (Even) ---
+            app.update();
+            let mut current_state = vec![];
+            apply_diffs(&mut current_state, get_and_clear_output::<i32>(app.world_mut()));
+            assert_eq!(current_state, vec![2, 4], "Initial state (even) is incorrect.");
+
+            // --- 2. Change Filter (to Odd) ---
+            *app.world_mut().resource_mut::<FilterMode>() = FilterMode(false);
+            app.update();
+            apply_diffs(&mut current_state, get_and_clear_output::<i32>(app.world_mut()));
+            assert_eq!(current_state, vec![1, 3], "State after switching to odd is incorrect.");
+
+            // --- 3. Source Vec Push (respecting Odd filter) --- Push an odd number, should
+            // appear.
+            source_vec.write(app.world_mut()).push(5);
+            app.update();
+            apply_diffs(&mut current_state, get_and_clear_output::<i32>(app.world_mut()));
+            assert_eq!(
+                current_state,
+                vec![1, 3, 5],
+                "State after pushing odd number is incorrect."
+            );
 
-        // Source vec is now [1, 2, 3, 4, 5, 6]. Evens are [2, 4, 6].
-        assert_eq!(
-            current_state,
-            vec![2, 4, 6],
-            "State after switching back to even is incorrect."
-        );
+            // Push an even number, should be filtered out.
+            source_vec.write(app.world_mut()).push(6);
+            app.update();
+            let diffs = get_and_clear_output::<i32>(app.world_mut());
+            assert!(
+                diffs.is_empty(),
+                "Pushing a filtered-out number should produce no diffs."
+            );
+            assert_eq!(
+                current_state,
+                vec![1, 3, 5],
+                "State should be unchanged after pushing even number."
+            );
 
-        // --- 5. Source Vec RemoveAt --- Remove `4` (even) from source vec (at index 3).
-        source_vec.write().remove(3);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        apply_diffs(&mut current_state, &get_and_clear_output::<i32>(app.world_mut()));
-        assert_eq!(current_state, vec![2, 6], "State after removing '4' is incorrect.");
+            // --- 4. Change Filter (back to Even) ---
+            *app.world_mut().resource_mut::<FilterMode>() = FilterMode(true);
+            app.update();
+            apply_diffs(&mut current_state, get_and_clear_output::<i32>(app.world_mut()));
 
-        // --- 6. Source Vec UpdateAt --- Update `3` (odd, at index 2) to `8` (even). This
-        // should insert `8` into the filtered list.
-        source_vec.write().set(2, 8);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        apply_diffs(&mut current_state, &get_and_clear_output::<i32>(app.world_mut()));
+            // Source vec is now [1, 2, 3, 4, 5, 6]. Evens are [2, 4, 6].
+            assert_eq!(
+                current_state,
+                vec![2, 4, 6],
+                "State after switching back to even is incorrect."
+            );
 
-        // Source is now [1, 2, 8, 5, 6]. Evens are [2, 8, 6].
-        assert_eq!(
-            current_state,
-            vec![2, 8, 6],
-            "State after updating 3 to 8 is incorrect."
-        );
+            // --- 5. Source Vec RemoveAt --- Remove `4` (even) from source vec (at index 3).
+            source_vec.write(app.world_mut()).remove(3);
+            app.update();
+            apply_diffs(&mut current_state, get_and_clear_output::<i32>(app.world_mut()));
+            assert_eq!(current_state, vec![2, 6], "State after removing '4' is incorrect.");
 
-        // Update `6` (even, at index 4) to `7` (odd). This should remove `6` from the
-        // filtered list.
-        source_vec.write().set(4, 7);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        apply_diffs(&mut current_state, &get_and_clear_output::<i32>(app.world_mut()));
+            // --- 6. Source Vec UpdateAt --- Update `3` (odd, at index 2) to `8` (even). This
+            // should insert `8` into the filtered list.
+            source_vec.write(app.world_mut()).set(2, 8);
+            app.update();
+            apply_diffs(&mut current_state, get_and_clear_output::<i32>(app.world_mut()));
 
-        // Source is now [1, 2, 8, 5, 7]. Evens are [2, 8].
-        assert_eq!(current_state, vec![2, 8], "State after updating 6 to 7 is incorrect.");
+            // Source is now [1, 2, 8, 5, 6]. Evens are [2, 8, 6].
+            assert_eq!(
+                current_state,
+                vec![2, 8, 6],
+                "State after updating 3 to 8 is incorrect."
+            );
 
-        // --- 7. Source Vec Clear ---
-        source_vec.write().clear();
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<i32>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Clear should produce one diff.");
-        assert_eq!(diffs[0], VecDiff::Clear, "Expected a Clear diff.");
-        apply_diffs(&mut current_state, &diffs);
-        assert!(current_state.is_empty(), "State after clear should be empty.");
+            // Update `6` (even, at index 4) to `7` (odd). This should remove `6` from the
+            // filtered list.
+            source_vec.write(app.world_mut()).set(4, 7);
+            app.update();
+            apply_diffs(&mut current_state, get_and_clear_output::<i32>(app.world_mut()));
+
+            // Source is now [1, 2, 8, 5, 7]. Evens are [2, 8].
+            assert_eq!(current_state, vec![2, 8], "State after updating 6 to 7 is incorrect.");
+
+            // --- 7. Source Vec Clear ---
+            source_vec.write(app.world_mut()).clear();
+            app.update();
+            let diffs = get_and_clear_output::<i32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Clear should produce one diff.");
+            assert_eq!(diffs[0], VecDiff::Clear, "Expected a Clear diff.");
+            apply_diffs(&mut current_state, diffs);
+            assert!(current_state.is_empty(), "State after clear should be empty.");
+
+            // --- Cleanup ---
+            handle.cleanup(app.world_mut());
+        }
 
-        // --- Cleanup ---
-        handle.cleanup(app.world_mut());
+        cleanup(true)
     }
 
     /// This test verifies the behavior of chaining multiple `.filter_signal()` calls.
@@ -5241,1110 +5355,1079 @@ mod tests {
     /// correctly as filter conditions change throughout the chain.
     #[test]
     fn test_filter_signal_chaining() {
-        let mut app = create_test_app();
-        app.init_resource::<SignalVecOutput<i32>>();
-
-        // --- Setup --- Resources to control the two filters
-        #[derive(Resource, Clone, PartialEq, Debug)]
-        struct IsPositive(bool);
-
-        #[derive(Resource, Clone, PartialEq, Debug)]
-        struct IsEven(bool);
-
-        // Initially, we only want non-positive numbers
-        app.insert_resource(IsPositive(false));
-
-        // And we want even numbers
-        app.insert_resource(IsEven(true));
-
-        // The source vector
-        let source_vec = MutableVec::from(vec![-2, -1, 0, 1, 2]);
-
-        // --- The Signal Chain ---
-        let final_signal = source_vec
-            .signal_vec()
-            // Filter 1: controlled by IsPositive resource.
-            .filter_signal(|In(val): In<i32>| {
-                SignalBuilder::from_resource::<IsPositive>()
-                    .map(move |In(res): In<IsPositive>| if res.0 { val > 0 } else { val <= 0 })
-            })
-            // Filter 2: controlled by IsEven resource.
-            .filter_signal(|In(val): In<i32>| {
-                SignalBuilder::from_resource::<IsEven>()
-                    .map(move |In(res): In<IsEven>| if res.0 { val % 2 == 0 } else { val % 2 != 0 })
-            });
-        let handle = final_signal
-            .for_each(capture_signal_vec_output)
-            .register(app.world_mut());
+        {
+            let mut app = create_test_app();
+            app.init_resource::<SignalVecOutput<i32>>();
 
-        // --- 1. Initial State --- IsPositive(false) -> pass [-2, -1, 0] IsEven(true)
-        //  -> from the above, pass [-2, 0]
-        app.update();
-        let mut current_state = vec![];
-        apply_diffs(&mut current_state, &get_and_clear_output::<i32>(app.world_mut()));
-        assert_eq!(current_state, vec![-2, 0], "Initial state is incorrect.");
-
-        // --- 2. Change the first filter's condition --- Now IsPositive(true) -> pass [1,
-        // 2] The second filter IsEven(true) is unchanged -> from the new set, pass [2]
-        // The combined effect should be to remove [-2, 0] and insert [2].
-        *app.world_mut().resource_mut::<IsPositive>() = IsPositive(true);
-        app.update();
-        apply_diffs(&mut current_state, &get_and_clear_output::<i32>(app.world_mut()));
-        assert_eq!(
-            current_state,
-            vec![2],
-            "State after flipping first filter is incorrect."
-        );
+            // --- Setup --- Resources to control the two filters
+            #[derive(Resource, Clone, PartialEq, Debug)]
+            struct IsPositive(bool);
 
-        // --- 3. Change the second filter's condition --- IsPositive(true) is unchanged
-        // -> pass [1, 2] IsEven(false) -> from the above, pass [1] The combined effect
-        // should be to remove [2] and insert [1].
-        *app.world_mut().resource_mut::<IsEven>() = IsEven(false);
-        app.update();
-        apply_diffs(&mut current_state, &get_and_clear_output::<i32>(app.world_mut()));
-        assert_eq!(
-            current_state,
-            vec![1],
-            "State after flipping second filter is incorrect."
-        );
+            #[derive(Resource, Clone, PartialEq, Debug)]
+            struct IsEven(bool);
 
-        // --- 4. Change the first filter back --- IsPositive(false) -> pass [-2, -1, 0]
-        // IsEven(false) -> from the above, pass [-1] The combined effect should be to
-        // remove [1] and insert [-1].
-        *app.world_mut().resource_mut::<IsPositive>() = IsPositive(false);
-        app.update();
-        apply_diffs(&mut current_state, &get_and_clear_output::<i32>(app.world_mut()));
-        assert_eq!(
-            current_state,
-            vec![-1],
-            "State after flipping first filter back is incorrect."
-        );
+            // Initially, we only want non-positive numbers
+            app.insert_resource(IsPositive(false));
 
-        // --- 5. Test source vec modification --- Add an item that should pass both
-        // current filters: IsPositive(false) and IsEven(false) -> Add -3. It should be
-        // pushed to the end of the filtered list.
-        source_vec.write().push(-3);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        apply_diffs(&mut current_state, &get_and_clear_output::<i32>(app.world_mut()));
-        assert_eq!(current_state, vec![-1, -3], "State after pushing -3 is incorrect.");
+            // And we want even numbers
+            app.insert_resource(IsEven(true));
 
-        // --- Cleanup ---
-        handle.cleanup(app.world_mut());
-    }
+            // The source vector
+            let source_vec = MutableVecBuilder::from([-2, -1, 0, 1, 2]).spawn(app.world_mut());
 
-    #[test]
-    fn test_to_signal() {
-        // A comprehensive test for `SignalVecExt::to_signal`, verifying that it
-        // correctly reconstructs the full vector state from all `VecDiff` types.
+            // --- The Signal Chain ---
+            let final_signal = source_vec
+                .signal_vec()
+                // Filter 1: controlled by IsPositive resource.
+                .filter_signal(|In(val): In<i32>| {
+                    SignalBuilder::from_resource::<IsPositive>()
+                        .map(move |In(res): In<IsPositive>| if res.0 { val > 0 } else { val <= 0 })
+                })
+                // Filter 2: controlled by IsEven resource.
+                .filter_signal(|In(val): In<i32>| {
+                    SignalBuilder::from_resource::<IsEven>()
+                        .map(move |In(res): In<IsEven>| if res.0 { val % 2 == 0 } else { val % 2 != 0 })
+                });
+            let handle = final_signal
+                .for_each(capture_signal_vec_output)
+                .register(app.world_mut());
+
+            // --- 1. Initial State --- IsPositive(false) -> pass [-2, -1, 0] IsEven(true)
+            //  -> from the above, pass [-2, 0]
+            app.update();
+            let mut current_state = vec![];
+            apply_diffs(&mut current_state, get_and_clear_output::<i32>(app.world_mut()));
+            assert_eq!(current_state, vec![-2, 0], "Initial state is incorrect.");
+
+            // --- 2. Change the first filter's condition --- Now IsPositive(true) -> pass [1,
+            // 2] The second filter IsEven(true) is unchanged -> from the new set, pass [2]
+            // The combined effect should be to remove [-2, 0] and insert [2].
+            *app.world_mut().resource_mut::<IsPositive>() = IsPositive(true);
+            app.update();
+            apply_diffs(&mut current_state, get_and_clear_output::<i32>(app.world_mut()));
+            assert_eq!(
+                current_state,
+                vec![2],
+                "State after flipping first filter is incorrect."
+            );
 
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-        app.init_resource::<FinalSignalOutput<Vec<String>>>();
-        let source_vec = MutableVec::from(vec!["a".to_string(), "b".to_string()]);
+            // --- 3. Change the second filter's condition --- IsPositive(true) is unchanged
+            // -> pass [1, 2] IsEven(false) -> from the above, pass [1] The combined effect
+            // should be to remove [2] and insert [1].
+            *app.world_mut().resource_mut::<IsEven>() = IsEven(false);
+            app.update();
+            apply_diffs(&mut current_state, get_and_clear_output::<i32>(app.world_mut()));
+            assert_eq!(
+                current_state,
+                vec![1],
+                "State after flipping second filter is incorrect."
+            );
 
-        // The signal chain under test.
-        let state_signal = source_vec.signal_vec().to_signal();
-        let handle = state_signal
-            .map(capture_final_output::<Vec<String>>)
-            .register(app.world_mut());
+            // --- 4. Change the first filter back --- IsPositive(false) -> pass [-2, -1, 0]
+            // IsEven(false) -> from the above, pass [-1] The combined effect should be to
+            // remove [1] and insert [-1].
+            *app.world_mut().resource_mut::<IsPositive>() = IsPositive(false);
+            app.update();
+            apply_diffs(&mut current_state, get_and_clear_output::<i32>(app.world_mut()));
+            assert_eq!(
+                current_state,
+                vec![-1],
+                "State after flipping first filter back is incorrect."
+            );
 
-        // --- 2. Test Initial State ---
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<Vec<String>>(app.world_mut()),
-            Some(vec!["a".to_string(), "b".to_string()]),
-            "Initial state was not correctly emitted."
-        );
+            // --- 5. Test source vec modification --- Add an item that should pass both
+            // current filters: IsPositive(false) and IsEven(false) -> Add -3. It should be
+            // pushed to the end of the filtered list.
+            source_vec.write(app.world_mut()).push(-3);
+            app.update();
+            apply_diffs(&mut current_state, get_and_clear_output::<i32>(app.world_mut()));
+            assert_eq!(current_state, vec![-1, -3], "State after pushing -3 is incorrect.");
 
-        // --- 3. Test Individual Diffs ---
-        // Test Push
-        source_vec.write().push("c".to_string());
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<Vec<String>>(app.world_mut()),
-            Some(vec!["a".to_string(), "b".to_string(), "c".to_string()]),
-            "State after Push is incorrect."
-        );
+            // --- Cleanup ---
+            handle.cleanup(app.world_mut());
+        }
 
-        // Test RemoveAt
-        source_vec.write().remove(1); // removes "b"
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<Vec<String>>(app.world_mut()),
-            Some(vec!["a".to_string(), "c".to_string()]),
-            "State after RemoveAt is incorrect."
-        );
+        cleanup(true)
+    }
 
-        // Test InsertAt
-        source_vec.write().insert(0, "x".to_string());
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<Vec<String>>(app.world_mut()),
-            Some(vec!["x".to_string(), "a".to_string(), "c".to_string()]),
-            "State after InsertAt is incorrect."
-        );
+    #[test]
+    fn test_to_signal() {
+        {
+            // A comprehensive test for `SignalVecExt::to_signal`, verifying that it
+            // correctly reconstructs the full vector state from all `VecDiff` types.
+
+            // --- 1. Setup ---
+            let mut app = create_test_app();
+            app.init_resource::<FinalSignalOutput<Vec<String>>>();
+            let source_vec = MutableVecBuilder::from(["a".to_string(), "b".to_string()]).spawn(app.world_mut());
+
+            // The signal chain under test.
+            let state_signal = source_vec.signal_vec().to_signal();
+            let handle = state_signal
+                .map(capture_final_output::<Vec<String>>)
+                .register(app.world_mut());
+
+            // --- 2. Test Initial State ---
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<Vec<String>>(app.world_mut()),
+                Some(vec!["a".to_string(), "b".to_string()]),
+                "Initial state was not correctly emitted."
+            );
 
-        // Test UpdateAt
-        source_vec.write().set(2, "C".to_string());
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<Vec<String>>(app.world_mut()),
-            Some(vec!["x".to_string(), "a".to_string(), "C".to_string()]),
-            "State after UpdateAt is incorrect."
-        );
+            // --- 3. Test Individual Diffs ---
+            // Test Push
+            source_vec.write(app.world_mut()).push("c".to_string());
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<Vec<String>>(app.world_mut()),
+                Some(vec!["a".to_string(), "b".to_string(), "c".to_string()]),
+                "State after Push is incorrect."
+            );
 
-        // Test Move
-        source_vec.write().move_item(2, 0); // moves "C" to the front
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<Vec<String>>(app.world_mut()),
-            Some(vec!["C".to_string(), "x".to_string(), "a".to_string()]),
-            "State after Move is incorrect."
-        );
+            // Test RemoveAt
+            source_vec.write(app.world_mut()).remove(1); // removes "b"
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<Vec<String>>(app.world_mut()),
+                Some(vec!["a".to_string(), "c".to_string()]),
+                "State after RemoveAt is incorrect."
+            );
 
-        // Test Pop
-        source_vec.write().pop(); // removes "a"
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<Vec<String>>(app.world_mut()),
-            Some(vec!["C".to_string(), "x".to_string()]),
-            "State after Pop is incorrect."
-        );
+            // Test InsertAt
+            source_vec.write(app.world_mut()).insert(0, "x".to_string());
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<Vec<String>>(app.world_mut()),
+                Some(vec!["x".to_string(), "a".to_string(), "c".to_string()]),
+                "State after InsertAt is incorrect."
+            );
 
-        // --- 4. Test No-Op Frame ---
-        // An update without any source changes should not emit a new state.
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<Vec<String>>(app.world_mut()),
-            None,
-            "Signal emitted on a no-op frame."
-        );
+            // Test UpdateAt
+            source_vec.write(app.world_mut()).set(2, "C".to_string());
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<Vec<String>>(app.world_mut()),
+                Some(vec!["x".to_string(), "a".to_string(), "C".to_string()]),
+                "State after UpdateAt is incorrect."
+            );
 
-        // --- 5. Test Batched Mutations ---
-        {
-            let mut writer = source_vec.write();
-            writer.push("y".to_string()); // State: ["C", "x", "y"]
-            writer.remove(0); // State: ["x", "y"]
-        }
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<Vec<String>>(app.world_mut()),
-            Some(vec!["x".to_string(), "y".to_string()]),
-            "State after batched mutations is incorrect."
-        );
+            // Test Move
+            source_vec.write(app.world_mut()).move_item(2, 0); // moves "C" to the front
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<Vec<String>>(app.world_mut()),
+                Some(vec!["C".to_string(), "x".to_string(), "a".to_string()]),
+                "State after Move is incorrect."
+            );
 
-        // --- 6. Test Clear ---
-        source_vec.write().clear();
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<Vec<String>>(app.world_mut()),
-            Some(vec![]),
-            "State after Clear is incorrect."
-        );
+            // Test Pop
+            source_vec.write(app.world_mut()).pop(); // removes "a"
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<Vec<String>>(app.world_mut()),
+                Some(vec!["C".to_string(), "x".to_string()]),
+                "State after Pop is incorrect."
+            );
 
-        // --- 7. Cleanup ---
-        handle.cleanup(app.world_mut());
+            // --- 4. Test No-Op Frame ---
+            // An update without any source changes should not emit a new state.
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<Vec<String>>(app.world_mut()),
+                None,
+                "Signal emitted on a no-op frame."
+            );
+
+            // --- 5. Test Batched Mutations ---
+            {
+                let mut writer = source_vec.write(app.world_mut());
+                writer.push("y".to_string()); // State: ["C", "x", "y"]
+                writer.remove(0); // State: ["x", "y"]
+            }
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<Vec<String>>(app.world_mut()),
+                Some(vec!["x".to_string(), "y".to_string()]),
+                "State after batched mutations is incorrect."
+            );
+
+            // --- 6. Test Clear ---
+            source_vec.write(app.world_mut()).clear();
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<Vec<String>>(app.world_mut()),
+                Some(vec![]),
+                "State after Clear is incorrect."
+            );
+
+            // --- 7. Cleanup ---
+            handle.cleanup(app.world_mut());
+        }
+
+        cleanup(true)
     }
 
     #[test]
     fn test_is_empty() {
-        // A comprehensive test for `SignalVecExt::is_empty`, verifying that it
-        // correctly emits true/false and re-emits on every source change, as intended.
-
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-        app.init_resource::<FinalSignalOutput<bool>>();
-        // Start with a non-empty vec to test the `false` state first.
-        let source_vec = MutableVec::from(vec!["a".to_string(), "b".to_string()]);
-
-        let is_empty_signal = source_vec.signal_vec().is_empty();
-        let handle = is_empty_signal
-            .map(capture_final_output::<bool>)
-            .register(app.world_mut());
+        {
+            // A comprehensive test for `SignalVecExt::is_empty`, verifying that it
+            // correctly emits true/false and re-emits on every source change, as intended.
+
+            // --- 1. Setup ---
+            let mut app = create_test_app();
+            app.init_resource::<FinalSignalOutput<bool>>();
+            // Start with a non-empty vec to test the `false` state first.
+            let source_vec = MutableVecBuilder::from(["a".to_string(), "b".to_string()]).spawn(app.world_mut());
+
+            let is_empty_signal = source_vec.signal_vec().is_empty();
+            let handle = is_empty_signal
+                .map(capture_final_output::<bool>)
+                .register(app.world_mut());
+
+            // --- 2. Test Initial State (Non-Empty) ---
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<bool>(app.world_mut()),
+                Some(false),
+                "Initial state for non-empty vec should be `false`."
+            );
 
-        // --- 2. Test Initial State (Non-Empty) ---
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<bool>(app.world_mut()),
-            Some(false),
-            "Initial state for non-empty vec should be `false`."
-        );
+            // --- 3. Test Operations that REMAIN Non-Empty ---
+            // These should re-emit `false` because the underlying vector changed, even if
+            // the emptiness state did not.
 
-        // --- 3. Test Operations that REMAIN Non-Empty ---
-        // These should re-emit `false` because the underlying vector changed, even if
-        // the emptiness state did not.
+            // Push: size 2 -> 3. Still not empty.
+            source_vec.write(app.world_mut()).push("c".to_string());
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<bool>(app.world_mut()),
+                Some(false),
+                "Pushing to a non-empty vec should re-emit `false`."
+            );
 
-        // Push: size 2 -> 3. Still not empty.
-        source_vec.write().push("c".to_string());
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<bool>(app.world_mut()),
-            Some(false),
-            "Pushing to a non-empty vec should re-emit `false`."
-        );
+            // UpdateAt: size 3 -> 3. Still not empty.
+            source_vec.write(app.world_mut()).set(0, "A".to_string());
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<bool>(app.world_mut()),
+                Some(false),
+                "Updating a non-empty vec should re-emit `false`."
+            );
 
-        // UpdateAt: size 3 -> 3. Still not empty.
-        source_vec.write().set(0, "A".to_string());
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<bool>(app.world_mut()),
-            Some(false),
-            "Updating a non-empty vec should re-emit `false`."
-        );
+            // Move: size 3 -> 3. Still not empty.
+            source_vec.write(app.world_mut()).move_item(0, 2);
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<bool>(app.world_mut()),
+                Some(false),
+                "Moving within a non-empty vec should re-emit `false`."
+            );
 
-        // Move: size 3 -> 3. Still not empty.
-        source_vec.write().move_item(0, 2);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<bool>(app.world_mut()),
-            Some(false),
-            "Moving within a non-empty vec should re-emit `false`."
-        );
+            // --- 4. Test Transition to Empty ---
+            // Current size is 3. We pop three times.
+            source_vec.write(app.world_mut()).pop(); // size 3 -> 2
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<bool>(app.world_mut()),
+                Some(false),
+                "Popping to size 2 should re-emit `false`."
+            );
 
-        // --- 4. Test Transition to Empty ---
-        // Current size is 3. We pop three times.
-        source_vec.write().pop(); // size 3 -> 2
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<bool>(app.world_mut()),
-            Some(false),
-            "Popping to size 2 should re-emit `false`."
-        );
+            source_vec.write(app.world_mut()).pop(); // size 2 -> 1
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<bool>(app.world_mut()),
+                Some(false),
+                "Popping to size 1 should re-emit `false`."
+            );
 
-        source_vec.write().pop(); // size 2 -> 1
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<bool>(app.world_mut()),
-            Some(false),
-            "Popping to size 1 should re-emit `false`."
-        );
+            // This is the pop that makes it empty. The state changes from false to true.
+            source_vec.write(app.world_mut()).pop(); // size 1 -> 0
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<bool>(app.world_mut()),
+                Some(true),
+                "Popping the last item should emit `true`."
+            );
 
-        // This is the pop that makes it empty. The state changes from false to true.
-        source_vec.write().pop(); // size 1 -> 0
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<bool>(app.world_mut()),
-            Some(true),
-            "Popping the last item should emit `true`."
-        );
+            // --- 5. Test True No-Op Frame ---
+            // An update without any source diffs should not cause an emit.
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<bool>(app.world_mut()),
+                None,
+                "Signal should not emit on a true no-op frame."
+            );
 
-        // --- 5. Test True No-Op Frame ---
-        // An update without any source diffs should not cause an emit.
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<bool>(app.world_mut()),
-            None,
-            "Signal should not emit on a true no-op frame."
-        );
+            // --- 6. Test Transition to Non-Empty ---
+            // The state changes from true to false.
+            source_vec.write(app.world_mut()).push("z".to_string());
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<bool>(app.world_mut()),
+                Some(false),
+                "Pushing to an empty vec should emit `false`."
+            );
 
-        // --- 6. Test Transition to Non-Empty ---
-        // The state changes from true to false.
-        source_vec.write().push("z".to_string());
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<bool>(app.world_mut()),
-            Some(false),
-            "Pushing to an empty vec should emit `false`."
-        );
+            // --- 7. Test Clear Operation ---
+            // The state changes from false to true.
+            source_vec.write(app.world_mut()).clear();
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<bool>(app.world_mut()),
+                Some(true),
+                "Clear on a non-empty vec should emit `true`."
+            );
 
-        // --- 7. Test Clear Operation ---
-        // The state changes from false to true.
-        source_vec.write().clear();
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<bool>(app.world_mut()),
-            Some(true),
-            "Clear on a non-empty vec should emit `true`."
-        );
+            // --- 8. Cleanup ---
+            handle.cleanup(app.world_mut());
+        }
 
-        // --- 8. Cleanup ---
-        handle.cleanup(app.world_mut());
+        cleanup(true)
     }
 
     #[test]
     fn test_len() {
-        // A comprehensive test for `SignalVecExt::len`, verifying that it correctly
-        // reports the vector's length and re-emits on every source change.
+        {
+            // A comprehensive test for `SignalVecExt::len`, verifying that it correctly
+            // reports the vector's length and re-emits on every source change.
 
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-        app.init_resource::<FinalSignalOutput<usize>>();
-        // Start with a non-empty vec.
-        let source_vec = MutableVec::from(vec!["a".to_string(), "b".to_string()]);
+            // --- 1. Setup ---
+            let mut app = create_test_app();
+            app.init_resource::<FinalSignalOutput<usize>>();
+            // Start with a non-empty vec.
+            let source_vec = MutableVecBuilder::from(["a".to_string(), "b".to_string()]).spawn(app.world_mut());
 
-        let len_signal = source_vec.signal_vec().len();
-        let handle = len_signal.map(capture_final_output::<usize>).register(app.world_mut());
+            let len_signal = source_vec.signal_vec().len();
+            let handle = len_signal.map(capture_final_output::<usize>).register(app.world_mut());
 
-        // --- 2. Test Initial State ---
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<usize>(app.world_mut()),
-            Some(2),
-            "Initial length should be 2."
-        );
+            // --- 2. Test Initial State ---
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<usize>(app.world_mut()),
+                Some(2),
+                "Initial length should be 2."
+            );
 
-        // --- 3. Test Length-Changing Operations ---
-        // Push: size 2 -> 3
-        source_vec.write().push("c".to_string());
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<usize>(app.world_mut()),
-            Some(3),
-            "Length after Push should be 3."
-        );
+            // --- 3. Test Length-Changing Operations ---
+            // Push: size 2 -> 3
+            source_vec.write(app.world_mut()).push("c".to_string());
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<usize>(app.world_mut()),
+                Some(3),
+                "Length after Push should be 3."
+            );
 
-        // InsertAt: size 3 -> 4
-        source_vec.write().insert(1, "x".to_string());
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<usize>(app.world_mut()),
-            Some(4),
-            "Length after InsertAt should be 4."
-        );
+            // InsertAt: size 3 -> 4
+            source_vec.write(app.world_mut()).insert(1, "x".to_string());
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<usize>(app.world_mut()),
+                Some(4),
+                "Length after InsertAt should be 4."
+            );
 
-        // RemoveAt: size 4 -> 3
-        source_vec.write().remove(2); // removes "b"
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<usize>(app.world_mut()),
-            Some(3),
-            "Length after RemoveAt should be 3."
-        );
+            // RemoveAt: size 4 -> 3
+            source_vec.write(app.world_mut()).remove(2); // removes "b"
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<usize>(app.world_mut()),
+                Some(3),
+                "Length after RemoveAt should be 3."
+            );
 
-        // Pop: size 3 -> 2
-        source_vec.write().pop(); // removes "c"
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<usize>(app.world_mut()),
-            Some(2),
-            "Length after Pop should be 2."
-        );
+            // Pop: size 3 -> 2
+            source_vec.write(app.world_mut()).pop(); // removes "c"
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<usize>(app.world_mut()),
+                Some(2),
+                "Length after Pop should be 2."
+            );
 
-        // --- 4. Test Length-Preserving Operations ---
-        // These should still re-emit the current length because the underlying vec changed.
+            // --- 4. Test Length-Preserving Operations ---
+            // These should still re-emit the current length because the underlying vec changed.
 
-        // UpdateAt: size 2 -> 2
-        source_vec.write().set(0, "A".to_string());
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<usize>(app.world_mut()),
-            Some(2),
-            "UpdateAt should re-emit length 2."
-        );
+            // UpdateAt: size 2 -> 2
+            source_vec.write(app.world_mut()).set(0, "A".to_string());
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<usize>(app.world_mut()),
+                Some(2),
+                "UpdateAt should re-emit length 2."
+            );
 
-        // Move: size 2 -> 2
-        source_vec.write().move_item(0, 1);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<usize>(app.world_mut()),
-            Some(2),
-            "Move should re-emit length 2."
-        );
+            // Move: size 2 -> 2
+            source_vec.write(app.world_mut()).move_item(0, 1);
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<usize>(app.world_mut()),
+                Some(2),
+                "Move should re-emit length 2."
+            );
 
-        // --- 5. Test True No-Op Frame ---
-        // An update without any source changes should not emit a new value.
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<usize>(app.world_mut()),
-            None,
-            "Signal emitted on a no-op frame."
-        );
+            // --- 5. Test True No-Op Frame ---
+            // An update without any source changes should not emit a new value.
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<usize>(app.world_mut()),
+                None,
+                "Signal emitted on a no-op frame."
+            );
 
-        // --- 6. Test Batched Mutations (Net Zero Length Change) ---
-        {
-            let mut writer = source_vec.write();
-            writer.push("y".to_string()); // len -> 3
-            writer.remove(0); // len -> 2
-        }
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<usize>(app.world_mut()),
-            Some(2),
-            "Batched mutations with net-zero length change should emit final length."
-        );
+            // --- 6. Test Batched Mutations (Net Zero Length Change) ---
+            {
+                let mut writer = source_vec.write(app.world_mut());
+                writer.push("y".to_string()); // len -> 3
+                writer.remove(0); // len -> 2
+            }
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<usize>(app.world_mut()),
+                Some(2),
+                "Batched mutations with net-zero length change should emit final length."
+            );
 
-        // --- 7. Test Clear Operation ---
-        // State changes from 2 to 0.
-        source_vec.write().clear();
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<usize>(app.world_mut()),
-            Some(0),
-            "Length after Clear should be 0."
-        );
+            // --- 7. Test Clear Operation ---
+            // State changes from 2 to 0.
+            source_vec.write(app.world_mut()).clear();
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<usize>(app.world_mut()),
+                Some(0),
+                "Length after Clear should be 0."
+            );
 
-        // --- 8. Test Transition from Empty ---
-        source_vec.write().push("z".to_string());
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<usize>(app.world_mut()),
-            Some(1),
-            "Length after pushing to an empty vec should be 1."
-        );
+            // --- 8. Test Transition from Empty ---
+            source_vec.write(app.world_mut()).push("z".to_string());
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<usize>(app.world_mut()),
+                Some(1),
+                "Length after pushing to an empty vec should be 1."
+            );
 
-        // --- 9. Cleanup ---
-        handle.cleanup(app.world_mut());
+            // --- 9. Cleanup ---
+            handle.cleanup(app.world_mut());
+        }
+
+        cleanup(true)
     }
 
     #[test]
     fn test_sum() {
-        // A comprehensive test for `SignalVecExt::sum`, verifying that it correctly
-        // calculates the sum and re-emits on every source change, as intended.
+        {
+            // A comprehensive test for `SignalVecExt::sum`, verifying that it correctly
+            // calculates the sum and re-emits on every source change, as intended.
 
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-        app.init_resource::<FinalSignalOutput<i32>>();
-        let source_vec = MutableVec::from(vec![10, 20]);
+            // --- 1. Setup ---
+            let mut app = create_test_app();
+            app.init_resource::<FinalSignalOutput<i32>>();
+            let source_vec = MutableVecBuilder::from([10, 20]).spawn(app.world_mut());
 
-        let sum_signal = source_vec.signal_vec().sum();
-        let handle = sum_signal.map(capture_final_output::<i32>).register(app.world_mut());
+            let sum_signal = source_vec.signal_vec().sum();
+            let handle = sum_signal.map(capture_final_output::<i32>).register(app.world_mut());
 
-        // --- 2. Test Initial State ---
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<i32>(app.world_mut()),
-            Some(30),
-            "Initial sum should be 30."
-        );
+            // --- 2. Test Initial State ---
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<i32>(app.world_mut()),
+                Some(30),
+                "Initial sum should be 30."
+            );
 
-        // --- 3. Test Value-Changing Operations ---
-        // Push: 30 -> 35
-        source_vec.write().push(5);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<i32>(app.world_mut()),
-            Some(35),
-            "Sum after Push should be 35."
-        );
+            // --- 3. Test Value-Changing Operations ---
+            // Push: 30 -> 35
+            source_vec.write(app.world_mut()).push(5);
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<i32>(app.world_mut()),
+                Some(35),
+                "Sum after Push should be 35."
+            );
 
-        // UpdateAt: 35 -> 45 (updates 10 to 20)
-        source_vec.write().set(0, 20);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<i32>(app.world_mut()),
-            Some(45),
-            "Sum after UpdateAt should be 45."
-        );
+            // UpdateAt: 35 -> 45 (updates 10 to 20)
+            source_vec.write(app.world_mut()).set(0, 20);
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<i32>(app.world_mut()),
+                Some(45),
+                "Sum after UpdateAt should be 45."
+            );
 
-        // RemoveAt: 45 -> 25 (removes 20 at index 1)
-        source_vec.write().remove(1);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<i32>(app.world_mut()),
-            Some(25),
-            "Sum after RemoveAt should be 25."
-        );
+            // RemoveAt: 45 -> 25 (removes 20 at index 1)
+            source_vec.write(app.world_mut()).remove(1);
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<i32>(app.world_mut()),
+                Some(25),
+                "Sum after RemoveAt should be 25."
+            );
 
-        // Pop: 25 -> 5 (removes 20 at the end)
-        source_vec.write().pop(); // vec is now [20]
-        source_vec.write().pop(); // vec is now []
-        source_vec.write().push(5); // vec is now [5]
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<i32>(app.world_mut()),
-            Some(5),
-            "Sum after multiple operations should be 5."
-        );
+            // Pop: 25 -> 5 (removes 20 at the end)
+            source_vec.write(app.world_mut()).pop(); // vec is now [20]
+            source_vec.write(app.world_mut()).pop(); // vec is now []
+            source_vec.write(app.world_mut()).push(5); // vec is now [5]
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<i32>(app.world_mut()),
+                Some(5),
+                "Sum after multiple operations should be 5."
+            );
 
-        // --- 4. Test Sum-Preserving Operation (`Move`) ---
-        // Add another element to make move meaningful
-        source_vec.write().push(15); // vec is now [5, 15], sum is 20
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<i32>(app.world_mut()),
-            Some(20),
-            "Sum after adding item for move test should be 20."
-        );
+            // --- 4. Test Sum-Preserving Operation (`Move`) ---
+            // Add another element to make move meaningful
+            source_vec.write(app.world_mut()).push(15); // vec is now [5, 15], sum is 20
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<i32>(app.world_mut()),
+                Some(20),
+                "Sum after adding item for move test should be 20."
+            );
 
-        // Move does not change the sum, but should still re-emit the value.
-        source_vec.write().move_item(0, 1); // vec is now [15, 5], sum is still 20
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<i32>(app.world_mut()),
-            Some(20),
-            "Move operation should re-emit the unchanged sum."
-        );
+            // Move does not change the sum, but should still re-emit the value.
+            source_vec.write(app.world_mut()).move_item(0, 1); // vec is now [15, 5], sum is still 20
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<i32>(app.world_mut()),
+                Some(20),
+                "Move operation should re-emit the unchanged sum."
+            );
 
-        // --- 5. Test True No-Op Frame ---
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<i32>(app.world_mut()),
-            None,
-            "Signal should not emit on a true no-op frame."
-        );
+            // --- 5. Test True No-Op Frame ---
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<i32>(app.world_mut()),
+                None,
+                "Signal should not emit on a true no-op frame."
+            );
 
-        // --- 6. Test Clear Operation ---
-        // State changes from 20 to 0.
-        source_vec.write().clear();
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<i32>(app.world_mut()),
-            Some(0),
-            "Sum after Clear should be 0."
-        );
+            // --- 6. Test Clear Operation ---
+            // State changes from 20 to 0.
+            source_vec.write(app.world_mut()).clear();
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<i32>(app.world_mut()),
+                Some(0),
+                "Sum after Clear should be 0."
+            );
 
-        // --- 7. Test Transition from Empty ---
-        source_vec.write().push(-10);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        assert_eq!(
-            get_and_clear_final_output::<i32>(app.world_mut()),
-            Some(-10),
-            "Sum after pushing to an empty vec should be -10."
-        );
+            // --- 7. Test Transition from Empty ---
+            source_vec.write(app.world_mut()).push(-10);
+            app.update();
+            assert_eq!(
+                get_and_clear_final_output::<i32>(app.world_mut()),
+                Some(-10),
+                "Sum after pushing to an empty vec should be -10."
+            );
 
-        // --- 8. Cleanup ---
-        handle.cleanup(app.world_mut());
+            // --- 8. Cleanup ---
+            handle.cleanup(app.world_mut());
+        }
+
+        cleanup(true)
     }
 
     #[test]
     fn test_chain() {
-        // A comprehensive test for `SignalVecExt::chain`, covering all `VecDiff`
-        // types on both the left and right sides, as well as edge cases like empty
-        // vectors.
+        {
+            // A comprehensive test for `SignalVecExt::chain`, covering all `VecDiff`
+            // types on both the left and right sides, as well as edge cases like empty
+            // vectors.
 
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-        app.init_resource::<SignalVecOutput<String>>();
+            // --- 1. Setup ---
+            let mut app = create_test_app();
+            app.init_resource::<SignalVecOutput<String>>();
 
-        let left_vec = MutableVec::from(vec!["L1".to_string(), "L2".to_string()]);
-        let right_vec = MutableVec::from(vec!["R1".to_string(), "R2".to_string()]);
+            let left_vec = MutableVecBuilder::from(["L1".to_string(), "L2".to_string()]).spawn(app.world_mut());
+            let right_vec = MutableVecBuilder::from(["R1".to_string(), "R2".to_string()]).spawn(app.world_mut());
 
-        let chained_signal = left_vec.signal_vec().chain(right_vec.signal_vec());
-        let handle = chained_signal
-            .for_each(capture_signal_vec_output)
-            .register(app.world_mut());
+            let chained_signal = left_vec.signal_vec().chain(right_vec.signal_vec());
+            let handle = chained_signal
+                .for_each(capture_signal_vec_output)
+                .register(app.world_mut());
 
-        let mut current_state: Vec<String> = vec![];
+            let mut current_state: Vec<String> = vec![];
 
-        // --- 2. Initial State ---
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            ["L1", "L2", "R1", "R2"]
-                .iter()
-                .map(|s| s.to_string())
-                .collect::<Vec<_>>(),
-            "Initial state was not correctly concatenated."
-        );
-        let left_len = || left_vec.read().len();
+            // --- 2. Initial State ---
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                ["L1", "L2", "R1", "R2"]
+                    .iter()
+                    .map(|s| s.to_string())
+                    .collect::<Vec<_>>(),
+                "Initial state was not correctly concatenated."
+            );
+            let left_len = |world: &World| left_vec.read(world).len();
 
-        // --- 3. Left-Side Mutations ---
+            // --- 3. Left-Side Mutations ---
 
-        // Push
-        left_vec.write().push("L3".to_string());
-        left_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(
-            diffs,
-            vec![VecDiff::InsertAt {
-                index: 2,
-                value: "L3".to_string()
-            }]
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            ["L1", "L2", "L3", "R1", "R2"]
-                .iter()
-                .map(|s| s.to_string())
-                .collect::<Vec<_>>()
-        );
+            // Push
+            left_vec.write(app.world_mut()).push("L3".to_string());
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(
+                diffs,
+                vec![VecDiff::InsertAt {
+                    index: 2,
+                    value: "L3".to_string()
+                }]
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                ["L1", "L2", "L3", "R1", "R2"]
+                    .iter()
+                    .map(|s| s.to_string())
+                    .collect::<Vec<_>>()
+            );
 
-        // UpdateAt
-        left_vec.write().set(0, "L1-new".to_string());
-        left_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(
-            diffs,
-            vec![VecDiff::UpdateAt {
-                index: 0,
-                value: "L1-new".to_string()
-            }]
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            ["L1-new", "L2", "L3", "R1", "R2"]
-                .iter()
-                .map(|s| s.to_string())
-                .collect::<Vec<_>>()
-        );
+            // UpdateAt
+            left_vec.write(app.world_mut()).set(0, "L1-new".to_string());
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(
+                diffs,
+                vec![VecDiff::UpdateAt {
+                    index: 0,
+                    value: "L1-new".to_string()
+                }]
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                ["L1-new", "L2", "L3", "R1", "R2"]
+                    .iter()
+                    .map(|s| s.to_string())
+                    .collect::<Vec<_>>()
+            );
 
-        // Move
-        left_vec.write().move_item(2, 0); // "L3" to front
-        left_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(
-            diffs,
-            vec![VecDiff::Move {
-                old_index: 2,
-                new_index: 0
-            }]
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            ["L3", "L1-new", "L2", "R1", "R2"]
-                .iter()
-                .map(|s| s.to_string())
-                .collect::<Vec<_>>()
-        );
+            // Move
+            left_vec.write(app.world_mut()).move_item(2, 0); // "L3" to front
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(
+                diffs,
+                vec![VecDiff::Move {
+                    old_index: 2,
+                    new_index: 0
+                }]
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                ["L3", "L1-new", "L2", "R1", "R2"]
+                    .iter()
+                    .map(|s| s.to_string())
+                    .collect::<Vec<_>>()
+            );
 
-        // Pop
-        left_vec.write().pop(); // removes "L2"
-        left_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs, vec![VecDiff::RemoveAt { index: 2 }]);
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            ["L3", "L1-new", "R1", "R2"]
-                .iter()
-                .map(|s| s.to_string())
-                .collect::<Vec<_>>()
-        );
+            // Pop
+            left_vec.write(app.world_mut()).pop(); // removes "L2"
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs, vec![VecDiff::RemoveAt { index: 2 }]);
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                ["L3", "L1-new", "R1", "R2"]
+                    .iter()
+                    .map(|s| s.to_string())
+                    .collect::<Vec<_>>()
+            );
 
-        // --- 4. Right-Side Mutations --- (left_len() is now 2)
+            // --- 4. Right-Side Mutations --- (left_len() is now 2)
 
-        // InsertAt
-        right_vec.write().insert(1, "R-insert".to_string());
-        right_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(
-            diffs,
-            vec![VecDiff::InsertAt {
-                index: left_len() + 1,
-                value: "R-insert".to_string()
-            }]
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            ["L3", "L1-new", "R1", "R-insert", "R2"]
-                .iter()
-                .map(|s| s.to_string())
-                .collect::<Vec<_>>()
-        );
+            // InsertAt
+            right_vec.write(app.world_mut()).insert(1, "R-insert".to_string());
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(
+                diffs,
+                vec![VecDiff::InsertAt {
+                    index: left_len(app.world()) + 1,
+                    value: "R-insert".to_string()
+                }]
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                ["L3", "L1-new", "R1", "R-insert", "R2"]
+                    .iter()
+                    .map(|s| s.to_string())
+                    .collect::<Vec<_>>()
+            );
 
-        // Move
-        right_vec.write().move_item(0, 2); // "R1" to end
-        right_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(
-            diffs,
-            vec![VecDiff::Move {
-                old_index: left_len(),
-                new_index: left_len() + 2
-            }]
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            ["L3", "L1-new", "R-insert", "R2", "R1"]
-                .iter()
-                .map(|s| s.to_string())
-                .collect::<Vec<_>>()
-        );
+            // Move
+            right_vec.write(app.world_mut()).move_item(0, 2); // "R1" to end
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(
+                diffs,
+                vec![VecDiff::Move {
+                    old_index: left_len(app.world()),
+                    new_index: left_len(app.world()) + 2
+                }]
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                ["L3", "L1-new", "R-insert", "R2", "R1"]
+                    .iter()
+                    .map(|s| s.to_string())
+                    .collect::<Vec<_>>()
+            );
 
-        // --- 5. `Replace` and `Clear` ---
+            // --- 5. `Replace` and `Clear` ---
 
-        // Replace Left
-        left_vec.write().replace(vec!["LX".to_string()]);
-        left_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        apply_diffs(&mut current_state, &diffs); // apply diffs to check final state
-        assert_eq!(
-            current_state,
-            ["LX", "R-insert", "R2", "R1"]
-                .iter()
-                .map(|s| s.to_string())
-                .collect::<Vec<_>>(),
-            "State after replacing left is incorrect"
-        );
+            // Replace Left
+            left_vec.write(app.world_mut()).replace(vec!["LX".to_string()]);
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            apply_diffs(&mut current_state, diffs); // apply diffs to check final state
+            assert_eq!(
+                current_state,
+                ["LX", "R-insert", "R2", "R1"]
+                    .iter()
+                    .map(|s| s.to_string())
+                    .collect::<Vec<_>>(),
+                "State after replacing left is incorrect"
+            );
 
-        // Replace Right
-        right_vec.write().replace(vec!["RY".to_string(), "RZ".to_string()]);
-        right_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            ["LX", "RY", "RZ"].iter().map(|s| s.to_string()).collect::<Vec<_>>(),
-            "State after replacing right is incorrect"
-        );
+            // Replace Right
+            right_vec
+                .write(app.world_mut())
+                .replace(vec!["RY".to_string(), "RZ".to_string()]);
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                ["LX", "RY", "RZ"].iter().map(|s| s.to_string()).collect::<Vec<_>>(),
+                "State after replacing right is incorrect"
+            );
 
-        // Clear Left
-        left_vec.write().clear();
-        left_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            ["RY", "RZ"].iter().map(|s| s.to_string()).collect::<Vec<_>>(),
-            "State after clearing left is incorrect"
-        );
-        assert_eq!(left_len(), 0);
+            // Clear Left
+            left_vec.write(app.world_mut()).clear();
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                ["RY", "RZ"].iter().map(|s| s.to_string()).collect::<Vec<_>>(),
+                "State after clearing left is incorrect"
+            );
+            assert_eq!(left_len(app.world()), 0);
 
-        // Push to Left when it's empty
-        left_vec.write().push("L-again".to_string());
-        left_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(
-            diffs,
-            vec![VecDiff::InsertAt {
-                index: 0,
-                value: "L-again".to_string()
-            }]
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            ["L-again", "RY", "RZ"]
-                .iter()
-                .map(|s| s.to_string())
-                .collect::<Vec<_>>()
-        );
+            // Push to Left when it's empty
+            left_vec.write(app.world_mut()).push("L-again".to_string());
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(
+                diffs,
+                vec![VecDiff::InsertAt {
+                    index: 0,
+                    value: "L-again".to_string()
+                }]
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                ["L-again", "RY", "RZ"]
+                    .iter()
+                    .map(|s| s.to_string())
+                    .collect::<Vec<_>>()
+            );
 
-        // Clear Right
-        right_vec.write().clear();
-        right_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            ["L-again"].iter().map(|s| s.to_string()).collect::<Vec<_>>(),
-            "State after clearing right is incorrect"
-        );
-        assert_eq!(right_vec.read().len(), 0);
+            // Clear Right
+            right_vec.write(app.world_mut()).clear();
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                ["L-again"].iter().map(|s| s.to_string()).collect::<Vec<_>>(),
+                "State after clearing right is incorrect"
+            );
+            assert_eq!(right_vec.read(app.world()).len(), 0);
 
-        // Push to Right when it's empty
-        right_vec.write().push("R-again".to_string());
-        right_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(
-            diffs,
-            vec![VecDiff::Push {
-                value: "R-again".to_string()
-            }]
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            ["L-again", "R-again"].iter().map(|s| s.to_string()).collect::<Vec<_>>()
-        );
+            // Push to Right when it's empty
+            right_vec.write(app.world_mut()).push("R-again".to_string());
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(
+                diffs,
+                vec![VecDiff::Push {
+                    value: "R-again".to_string()
+                }]
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                ["L-again", "R-again"].iter().map(|s| s.to_string()).collect::<Vec<_>>()
+            );
 
-        // --- 6. Batched Diffs ---
-        left_vec.write().pop(); // L-again is gone
-        right_vec.write().push("R-batch".to_string());
-        left_vec.flush_into_world(app.world_mut());
-        right_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            ["R-again", "R-batch"].iter().map(|s| s.to_string()).collect::<Vec<_>>()
-        );
+            // --- 6. Batched Diffs ---
+            left_vec.write(app.world_mut()).pop(); // L-again is gone
+            right_vec.write(app.world_mut()).push("R-batch".to_string());
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                ["R-again", "R-batch"].iter().map(|s| s.to_string()).collect::<Vec<_>>()
+            );
 
-        // --- 7. Cleanup ---
-        handle.cleanup(app.world_mut());
+            // --- 7. Cleanup ---
+            handle.cleanup(app.world_mut());
+        }
+
+        cleanup(true)
     }
 
     #[test]
     fn test_intersperse() {
-        // A comprehensive test for `SignalVecExt::intersperse`, covering all `VecDiff`
-        // types and various edge cases.
-
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-        app.init_resource::<SignalVecOutput<String>>();
-
-        let separator = "sep".to_string();
-        let source_vec = MutableVec::new(); // Start empty for initial tests
-
-        let interspersed_signal = source_vec.signal_vec().intersperse(separator.clone());
-        let handle = interspersed_signal
-            .for_each(capture_signal_vec_output)
-            .register(app.world_mut());
-
-        let mut current_state: Vec<String> = vec![];
-
-        // --- 2. Test Initial and Edge Cases ---
-
-        // Initial state is empty.
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert!(diffs.is_empty(), "Initial empty vec should produce no diffs.");
-        assert!(current_state.is_empty());
-
-        // Replace with empty
-        source_vec.write().replace(Vec::<String>::new());
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs, vec![VecDiff::Replace { values: vec![] }]);
-        apply_diffs(&mut current_state, &diffs);
-        assert!(current_state.is_empty());
-
-        // Replace with one item (no separators)
-        source_vec.write().replace(vec!["A".to_string()]);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(
-            diffs,
-            vec![VecDiff::Replace {
-                values: vec!["A".to_string()]
-            }]
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec!["A".to_string()]);
-
-        // Replace with multiple items
-        source_vec.write().replace(vec!["A".to_string(), "B".to_string()]);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(
-            diffs,
-            vec![VecDiff::Replace {
-                values: vec!["A".to_string(), separator.clone(), "B".to_string()]
-            }]
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec!["A".to_string(), separator.clone(), "B".to_string()]);
-
-        // --- 3. Test Push & Pop ---
-
-        // Push to multi-item vec
-        source_vec.write().push("C".to_string());
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            ["A", "sep", "B", "sep", "C"]
-                .iter()
-                .map(|&s| s.to_string())
-                .collect::<Vec<_>>()
-        );
-
-        // Pop from multi-item vec
-        source_vec.write().pop();
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            ["A", "sep", "B"].iter().map(|&s| s.to_string()).collect::<Vec<_>>()
-        );
+        {
+            // A comprehensive test for `SignalVecExt::intersperse`, covering all `VecDiff`
+            // types and various edge cases.
+
+            // --- 1. Setup ---
+            let mut app = create_test_app();
+            app.init_resource::<SignalVecOutput<String>>();
+
+            let separator = "sep".to_string();
+            let source_vec = MutableVec::from(app.world_mut()); // Start empty for initial tests
+
+            let interspersed_signal = source_vec.signal_vec().intersperse(separator.clone());
+            let handle = interspersed_signal
+                .for_each(capture_signal_vec_output)
+                .register(app.world_mut());
+
+            let mut current_state: Vec<String> = vec![];
+
+            // --- 2. Test Initial and Edge Cases ---
+
+            // Initial state is empty.
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert!(diffs.is_empty(), "Initial empty vec should produce no diffs.");
+            assert!(current_state.is_empty());
+
+            // Replace with empty
+            source_vec.write(app.world_mut()).replace(Vec::<String>::new());
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs, vec![VecDiff::Replace { values: vec![] }]);
+            apply_diffs(&mut current_state, diffs);
+            assert!(current_state.is_empty());
+
+            // Replace with one item (no separators)
+            source_vec.write(app.world_mut()).replace(vec!["A".to_string()]);
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(
+                diffs,
+                vec![VecDiff::Replace {
+                    values: vec!["A".to_string()]
+                }]
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec!["A".to_string()]);
+
+            // Replace with multiple items
+            source_vec
+                .write(app.world_mut())
+                .replace(vec!["A".to_string(), "B".to_string()]);
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(
+                diffs,
+                vec![VecDiff::Replace {
+                    values: vec!["A".to_string(), separator.clone(), "B".to_string()]
+                }]
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec!["A".to_string(), separator.clone(), "B".to_string()]);
 
-        // Pop until one item left
-        source_vec.write().pop();
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec!["A".to_string()]);
+            // --- 3. Test Push & Pop ---
 
-        // Pop the last item
-        source_vec.write().pop();
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        apply_diffs(&mut current_state, &diffs);
-        assert!(current_state.is_empty());
+            // Push to multi-item vec
+            source_vec.write(app.world_mut()).push("C".to_string());
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                ["A", "sep", "B", "sep", "C"]
+                    .iter()
+                    .map(|&s| s.to_string())
+                    .collect::<Vec<_>>()
+            );
 
-        // Push to empty vec
-        source_vec.write().push("Z".to_string());
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec!["Z".to_string()]);
+            // Pop from multi-item vec
+            source_vec.write(app.world_mut()).pop();
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                ["A", "sep", "B"].iter().map(|&s| s.to_string()).collect::<Vec<_>>()
+            );
 
-        // --- 4. Test Insert & Remove ---
-        source_vec.write().replace(vec!["A".to_string(), "C".to_string()]);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        apply_diffs(&mut current_state, &get_and_clear_output::<String>(app.world_mut()));
-        assert_eq!(
-            current_state,
-            ["A", "sep", "C"].iter().map(|&s| s.to_string()).collect::<Vec<_>>()
-        );
+            // Pop until one item left
+            source_vec.write(app.world_mut()).pop();
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec!["A".to_string()]);
+
+            // Pop the last item
+            source_vec.write(app.world_mut()).pop();
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert!(current_state.is_empty());
+
+            // Push to empty vec
+            source_vec.write(app.world_mut()).push("Z".to_string());
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec!["Z".to_string()]);
+
+            // --- 4. Test Insert & Remove ---
+            source_vec
+                .write(app.world_mut())
+                .replace(vec!["A".to_string(), "C".to_string()]);
+            app.update();
+            apply_diffs(&mut current_state, get_and_clear_output::<String>(app.world_mut()));
+            assert_eq!(
+                current_state,
+                ["A", "sep", "C"].iter().map(|&s| s.to_string()).collect::<Vec<_>>()
+            );
 
-        // Insert in middle
-        source_vec.write().insert(1, "B".to_string());
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            ["A", "sep", "B", "sep", "C"]
-                .iter()
-                .map(|&s| s.to_string())
-                .collect::<Vec<_>>()
-        );
+            // Insert in middle
+            source_vec.write(app.world_mut()).insert(1, "B".to_string());
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                ["A", "sep", "B", "sep", "C"]
+                    .iter()
+                    .map(|&s| s.to_string())
+                    .collect::<Vec<_>>()
+            );
 
-        // Insert at beginning
-        source_vec.write().insert(0, "S".to_string());
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            ["S", "sep", "A", "sep", "B", "sep", "C"]
-                .iter()
-                .map(|&s| s.to_string())
-                .collect::<Vec<_>>()
-        );
+            // Insert at beginning
+            source_vec.write(app.world_mut()).insert(0, "S".to_string());
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                ["S", "sep", "A", "sep", "B", "sep", "C"]
+                    .iter()
+                    .map(|&s| s.to_string())
+                    .collect::<Vec<_>>()
+            );
 
-        // Insert at end (should behave like push)
-        source_vec.write().insert(4, "E".to_string());
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            ["S", "sep", "A", "sep", "B", "sep", "C", "sep", "E"]
-                .iter()
-                .map(|&s| s.to_string())
-                .collect::<Vec<_>>(),
-            "InsertAt at end failed"
-        );
+            // Insert at end (should behave like push)
+            source_vec.write(app.world_mut()).insert(4, "E".to_string());
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                ["S", "sep", "A", "sep", "B", "sep", "C", "sep", "E"]
+                    .iter()
+                    .map(|&s| s.to_string())
+                    .collect::<Vec<_>>(),
+                "InsertAt at end failed"
+            );
 
-        // Remove from middle ("A")
-        source_vec.write().remove(1);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            ["S", "sep", "B", "sep", "C", "sep", "E"]
-                .iter()
-                .map(|&s| s.to_string())
-                .collect::<Vec<_>>()
-        );
+            // Remove from middle ("A")
+            source_vec.write(app.world_mut()).remove(1);
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                ["S", "sep", "B", "sep", "C", "sep", "E"]
+                    .iter()
+                    .map(|&s| s.to_string())
+                    .collect::<Vec<_>>()
+            );
 
-        // Remove from end ("E")
-        source_vec.write().remove(3);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            ["S", "sep", "B", "sep", "C"]
-                .iter()
-                .map(|&s| s.to_string())
-                .collect::<Vec<_>>()
-        );
+            // Remove from end ("E")
+            source_vec.write(app.world_mut()).remove(3);
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                ["S", "sep", "B", "sep", "C"]
+                    .iter()
+                    .map(|&s| s.to_string())
+                    .collect::<Vec<_>>()
+            );
 
-        // --- 5. Test Update & Move ---
-        // Update
-        source_vec.write().set(1, "Beta".to_string()); // "B" -> "Beta"
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(
-            diffs,
-            vec![VecDiff::UpdateAt {
-                index: 2,
-                value: "Beta".to_string()
-            }]
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            ["S", "sep", "Beta", "sep", "C"]
-                .iter()
-                .map(|&s| s.to_string())
-                .collect::<Vec<_>>()
-        );
+            // --- 5. Test Update & Move ---
+            // Update
+            source_vec.write(app.world_mut()).set(1, "Beta".to_string()); // "B" -> "Beta"
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(
+                diffs,
+                vec![VecDiff::UpdateAt {
+                    index: 2,
+                    value: "Beta".to_string()
+                }]
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                ["S", "sep", "Beta", "sep", "C"]
+                    .iter()
+                    .map(|&s| s.to_string())
+                    .collect::<Vec<_>>()
+            );
 
-        // Move
-        // Source: ["S", "Beta", "C"] -> move 0 to 2 -> ["Beta", "C", "S"]
-        // Interspersed: ["S", "sep", "Beta", "sep", "C"] -> ["Beta", "sep", "C", "sep", "S"]
-        source_vec.write().move_item(0, 2);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        // The exact diffs for Move can be complex; we verify the final state.
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            ["Beta", "sep", "C", "sep", "S"]
-                .iter()
-                .map(|&s| s.to_string())
-                .collect::<Vec<_>>(),
-            "Move failed"
-        );
+            // Move
+            // Source: ["S", "Beta", "C"] -> move 0 to 2 -> ["Beta", "C", "S"]
+            // Interspersed: ["S", "sep", "Beta", "sep", "C"] -> ["Beta", "sep", "C", "sep", "S"]
+            source_vec.write(app.world_mut()).move_item(0, 2);
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            // The exact diffs for Move can be complex; we verify the final state.
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                ["Beta", "sep", "C", "sep", "S"]
+                    .iter()
+                    .map(|&s| s.to_string())
+                    .collect::<Vec<_>>(),
+                "Move failed"
+            );
 
-        // --- 6. Clear ---
-        source_vec.write().clear();
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<String>(app.world_mut());
-        assert_eq!(diffs, vec![VecDiff::Clear]);
-        apply_diffs(&mut current_state, &diffs);
-        assert!(current_state.is_empty());
+            // --- 6. Clear ---
+            source_vec.write(app.world_mut()).clear();
+            app.update();
+            let diffs = get_and_clear_output::<String>(app.world_mut());
+            assert_eq!(diffs, vec![VecDiff::Clear]);
+            apply_diffs(&mut current_state, diffs);
+            assert!(current_state.is_empty());
 
-        // --- 7. Cleanup ---
-        handle.cleanup(app.world_mut());
+            // --- 7. Cleanup ---
+            handle.cleanup(app.world_mut());
+        }
+
+        cleanup(true)
     }
 
     /// A helper enum to represent the items in our final interspersed vector,
@@ -6403,491 +6486,489 @@ mod tests {
     ///    `Move`, etc.) occur in the source vector.
     #[test]
     fn test_intersperse_with() {
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-        // Use `insert_resource` with an explicit value, as `ItemOrSep` doesn't have a Default.
-        app.insert_resource(SignalVecOutput::<ItemOrSep>(Vec::new()));
-
-        let source_vec = MutableVec::from(vec![10u32, 20, 30]);
-
-        // CORRECTION: The closure's input parameter must be the concrete type
-        // `signal::Source<Option<usize>>`, not a generic `impl Signal`. This satisfies
-        // the `IntoSystem` trait bound.
-        let separator_factory =
-            |In(index_signal): In<crate::signal::Source<Option<usize>>>| ItemOrSep::Sep(index_signal);
-
-        let interspersed_signal = source_vec
-            .signal_vec()
-            .map_in(ItemOrSep::Item) // Map source items into our test enum
-            .intersperse_with(separator_factory);
-
-        let handle = interspersed_signal
-            .for_each(capture_signal_vec_output)
-            .register(app.world_mut());
-
-        // This local vec will mirror the state of the final interspersed signal.
-        let mut current_state: Vec<ItemOrSep> = vec![];
-
-        // --- 2. Test Initial State ---
-        app.update();
-        apply_diffs(&mut current_state, &get_and_clear_output::<ItemOrSep>(app.world_mut()));
+        {
+            // --- 1. Setup ---
+            let mut app = create_test_app();
+            // Use `insert_resource` with an explicit value, as `ItemOrSep` doesn't have a Default.
+            app.insert_resource(SignalVecOutput::<ItemOrSep>(Vec::new()));
+
+            let source_vec = MutableVecBuilder::from([10u32, 20, 30]).spawn(app.world_mut());
+
+            // CORRECTION: The closure's input parameter must be the concrete type
+            // `signal::Source<Option<usize>>`, not a generic `impl Signal`. This satisfies
+            // the `IntoSystem` trait bound.
+            let separator_factory =
+                |In(index_signal): In<crate::signal::Source<Option<usize>>>| ItemOrSep::Sep(index_signal);
+
+            let interspersed_signal = source_vec
+                .signal_vec()
+                .map_in(ItemOrSep::Item) // Map source items into our test enum
+                .intersperse_with(separator_factory);
+
+            let handle = interspersed_signal
+                .for_each(capture_signal_vec_output)
+                .register(app.world_mut());
+
+            // This local vec will mirror the state of the final interspersed signal.
+            let mut current_state: Vec<ItemOrSep> = vec![];
+
+            // --- 2. Test Initial State ---
+            app.update();
+            apply_diffs(&mut current_state, get_and_clear_output::<ItemOrSep>(app.world_mut()));
+
+            // CORRECTION: Use the correct `signal::Source` for the placeholder.
+            // We also need to provide the type hint for the closure to resolve ambiguity.
+            let placeholder_sep = ItemOrSep::Sep(SignalBuilder::from_system(|_: In<()>| None::<usize>));
+            assert_eq!(
+                current_state,
+                vec![
+                    ItemOrSep::Item(10),
+                    placeholder_sep.clone(),
+                    ItemOrSep::Item(20),
+                    placeholder_sep.clone(),
+                    ItemOrSep::Item(30),
+                ],
+                "Initial structure is incorrect."
+            );
 
-        // CORRECTION: Use the correct `signal::Source` for the placeholder.
-        // We also need to provide the type hint for the closure to resolve ambiguity.
-        let placeholder_sep = ItemOrSep::Sep(SignalBuilder::from_system(|_: In<()>| None::<usize>));
-        assert_eq!(
-            current_state,
-            vec![
-                ItemOrSep::Item(10),
-                placeholder_sep.clone(),
-                ItemOrSep::Item(20),
-                placeholder_sep.clone(),
-                ItemOrSep::Item(30),
-            ],
-            "Initial structure is incorrect."
-        );
+            // Verify the indices of the separators by registering and polling their signals.
+            let mut handles_to_clean = Vec::new();
+            let sep_signals: Vec<_> = current_state
+                .iter()
+                .filter_map(|x| match x {
+                    ItemOrSep::Sep(s) => Some(s.clone()),
+                    _ => None,
+                })
+                .collect();
+
+            assert_eq!(sep_signals.len(), 2);
+            let h1 = sep_signals[0].clone().register(app.world_mut());
+            let h2 = sep_signals[1].clone().register(app.world_mut());
+            assert_eq!(poll_index(app.world_mut(), &h1), Some(0));
+            assert_eq!(poll_index(app.world_mut(), &h2), Some(1));
+            handles_to_clean.push(h1);
+            handles_to_clean.push(h2);
+
+            // --- 3. Test Push ---
+            source_vec.write(app.world_mut()).push(40);
+            app.update();
+            apply_diffs(&mut current_state, get_and_clear_output::<ItemOrSep>(app.world_mut()));
+
+            assert_eq!(current_state.len(), 7, "State length after push is incorrect.");
+            assert_eq!(current_state[6], ItemOrSep::Item(40));
+
+            if let ItemOrSep::Sep(signal) = &current_state[5] {
+                let h = signal.clone().register(app.world_mut());
+                assert_eq!(
+                    poll_index(app.world_mut(), &h),
+                    Some(2),
+                    "New separator's index is incorrect."
+                );
+                handles_to_clean.push(h);
+            } else {
+                panic!("Expected a separator at index 5");
+            }
 
-        // Verify the indices of the separators by registering and polling their signals.
-        let mut handles_to_clean = Vec::new();
-        let sep_signals: Vec<_> = current_state
-            .iter()
-            .filter_map(|x| match x {
-                ItemOrSep::Sep(s) => Some(s.clone()),
-                _ => None,
-            })
-            .collect();
-
-        assert_eq!(sep_signals.len(), 2);
-        let h1 = sep_signals[0].clone().register(app.world_mut());
-        let h2 = sep_signals[1].clone().register(app.world_mut());
-        assert_eq!(poll_index(app.world_mut(), &h1), Some(0));
-        assert_eq!(poll_index(app.world_mut(), &h2), Some(1));
-        handles_to_clean.push(h1);
-        handles_to_clean.push(h2);
-
-        // --- 3. Test Push ---
-        source_vec.write().push(40);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        apply_diffs(&mut current_state, &get_and_clear_output::<ItemOrSep>(app.world_mut()));
+            // --- 4. Test RemoveAt (from middle) and Index Reactivity ---
+            source_vec.write(app.world_mut()).remove(1); // Removes 20
+            app.update();
+            apply_diffs(&mut current_state, get_and_clear_output::<ItemOrSep>(app.world_mut()));
 
-        assert_eq!(current_state.len(), 7, "State length after push is incorrect.");
-        assert_eq!(current_state[6], ItemOrSep::Item(40));
+            assert_eq!(current_state.len(), 5, "State length after RemoveAt is incorrect.");
+            assert_eq!(
+                current_state,
+                vec![
+                    ItemOrSep::Item(10),
+                    placeholder_sep.clone(),
+                    ItemOrSep::Item(30),
+                    placeholder_sep.clone(),
+                    ItemOrSep::Item(40),
+                ],
+                "Structure after RemoveAt is incorrect."
+            );
 
-        if let ItemOrSep::Sep(signal) = &current_state[5] {
-            let h = signal.clone().register(app.world_mut());
+            // The crucial test: the separator that was after `30` (original index 2) should
+            // now have its index signal updated to `1`.
+            let sep_signals_after_remove: Vec<_> = current_state
+                .iter()
+                .filter_map(|x| {
+                    if let ItemOrSep::Sep(s) = x {
+                        Some(s.clone())
+                    } else {
+                        None
+                    }
+                })
+                .collect();
+            assert_eq!(sep_signals_after_remove.len(), 2);
+            let h_rem_1 = sep_signals_after_remove[0].clone().register(app.world_mut());
+            let h_rem_2 = sep_signals_after_remove[1].clone().register(app.world_mut());
+            assert_eq!(poll_index(app.world_mut(), &h_rem_1), Some(0));
             assert_eq!(
-                poll_index(app.world_mut(), &h),
-                Some(2),
-                "New separator's index is incorrect."
+                poll_index(app.world_mut(), &h_rem_2),
+                Some(1),
+                "Separator index did not reactively update after RemoveAt."
             );
-            handles_to_clean.push(h);
-        } else {
-            panic!("Expected a separator at index 5");
+            handles_to_clean.push(h_rem_1);
+            handles_to_clean.push(h_rem_2);
+
+            // --- 5. Test Clear ---
+            source_vec.write(app.world_mut()).clear();
+            app.update();
+            apply_diffs(&mut current_state, get_and_clear_output::<ItemOrSep>(app.world_mut()));
+            assert!(current_state.is_empty(), "State after Clear should be empty.");
+
+            // --- 6. Final Cleanup ---
+            handle.cleanup(app.world_mut());
+            for h in handles_to_clean {
+                h.cleanup(app.world_mut());
+            }
+            app.update(); // Run one last time to process cleanup commands.
         }
 
-        // --- 4. Test RemoveAt (from middle) and Index Reactivity ---
-        source_vec.write().remove(1); // Removes 20
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        apply_diffs(&mut current_state, &get_and_clear_output::<ItemOrSep>(app.world_mut()));
-
-        assert_eq!(current_state.len(), 5, "State length after RemoveAt is incorrect.");
-        assert_eq!(
-            current_state,
-            vec![
-                ItemOrSep::Item(10),
-                placeholder_sep.clone(),
-                ItemOrSep::Item(30),
-                placeholder_sep.clone(),
-                ItemOrSep::Item(40),
-            ],
-            "Structure after RemoveAt is incorrect."
-        );
-
-        // The crucial test: the separator that was after `30` (original index 2) should
-        // now have its index signal updated to `1`.
-        let sep_signals_after_remove: Vec<_> = current_state
-            .iter()
-            .filter_map(|x| {
-                if let ItemOrSep::Sep(s) = x {
-                    Some(s.clone())
-                } else {
-                    None
-                }
-            })
-            .collect();
-        assert_eq!(sep_signals_after_remove.len(), 2);
-        let h_rem_1 = sep_signals_after_remove[0].clone().register(app.world_mut());
-        let h_rem_2 = sep_signals_after_remove[1].clone().register(app.world_mut());
-        assert_eq!(poll_index(app.world_mut(), &h_rem_1), Some(0));
-        assert_eq!(
-            poll_index(app.world_mut(), &h_rem_2),
-            Some(1),
-            "Separator index did not reactively update after RemoveAt."
-        );
-        handles_to_clean.push(h_rem_1);
-        handles_to_clean.push(h_rem_2);
-
-        // --- 5. Test Clear ---
-        source_vec.write().clear();
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        apply_diffs(&mut current_state, &get_and_clear_output::<ItemOrSep>(app.world_mut()));
-        assert!(current_state.is_empty(), "State after Clear should be empty.");
-
-        // --- 6. Final Cleanup ---
-        handle.cleanup(app.world_mut());
-        for h in handles_to_clean {
-            h.cleanup(app.world_mut());
-        }
-        app.update(); // Run one last time to process cleanup commands.
+        cleanup(true)
     }
 
     #[test]
     fn test_sort_by() {
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-        app.init_resource::<SignalVecOutput<(u32, char)>>();
-        let source_vec = MutableVec::from(vec![(3, 'c'), (1, 'a'), (4, 'd')]);
-        let compare_system = |In((left, right)): In<((u32, char), (u32, char))>| left.0.cmp(&right.0);
-        let sorted_signal = source_vec.signal_vec().sort_by(compare_system);
-        let handle = sorted_signal
-            .for_each(capture_signal_vec_output)
-            .register(app.world_mut());
-        let mut current_state: Vec<(u32, char)> = vec![];
-
-        // --- 2. Test Initial State ---
-        app.update();
-        let diffs = get_and_clear_output::<(u32, char)>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Initial update should produce one Replace diff.");
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            vec![(1, 'a'), (3, 'c'), (4, 'd')],
-            "Initial state is not correctly sorted."
-        );
-
-        // --- 3. Test Push ---
-        source_vec.write().push((2, 'b'));
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<(u32, char)>(app.world_mut());
-        assert_eq!(
-            diffs[0],
-            VecDiff::InsertAt {
-                index: 1,
-                value: (2, 'b')
-            }
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec![(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]);
+        {
+            // --- 1. Setup ---
+            let mut app = create_test_app();
+            app.init_resource::<SignalVecOutput<(u32, char)>>();
+            let source_vec = MutableVecBuilder::from([(3, 'c'), (1, 'a'), (4, 'd')]).spawn(app.world_mut());
+            let compare_system = |In((left, right)): In<((u32, char), (u32, char))>| left.0.cmp(&right.0);
+            let sorted_signal = source_vec.signal_vec().sort_by(compare_system);
+            let handle = sorted_signal
+                .for_each(capture_signal_vec_output)
+                .register(app.world_mut());
+            let mut current_state: Vec<(u32, char)> = vec![];
+
+            // --- 2. Test Initial State ---
+            app.update();
+            let diffs = get_and_clear_output::<(u32, char)>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Initial update should produce one Replace diff.");
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec![(1, 'a'), (3, 'c'), (4, 'd')],
+                "Initial state is not correctly sorted."
+            );
 
-        // --- 4. Test RemoveAt ---
-        source_vec.write().remove(1); // Removes (1, 'a')
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<(u32, char)>(app.world_mut());
-        assert_eq!(diffs[0], VecDiff::RemoveAt { index: 0 });
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec![(2, 'b'), (3, 'c'), (4, 'd')]);
-
-        // --- 5. Test UpdateAt ---
-        // Case A: Update without changing sort order.
-        source_vec.write().set(0, (3, 'C')); // Was (3, 'c')
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<(u32, char)>(app.world_mut());
-        assert_eq!(diffs.len(), 1);
-        assert_eq!(
-            diffs[0],
-            VecDiff::UpdateAt {
-                index: 1,
-                value: (3, 'C')
-            }
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec![(2, 'b'), (3, 'C'), (4, 'd')]);
-
-        // Case B: Update that changes sort order.
-        // Source is now [(3, 'C'), (4, 'd'), (2, 'b')]. Sorted is [(2, 'b'), (3, 'C'), (4, 'd')]
-        // Update (4, 'd') at source index 1 to (0, 'z').
-        // The old item was at sorted index 2. The new item should be at sorted index 0.
-        source_vec.write().set(1, (0, 'z'));
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<(u32, char)>(app.world_mut());
-        assert_eq!(diffs.len(), 2, "Update with sort change should be Remove+Insert.");
-        assert_eq!(
-            diffs,
-            vec![
-                VecDiff::RemoveAt { index: 2 }, // Remove (4, 'd') from old sorted pos
+            // --- 3. Test Push ---
+            source_vec.write(app.world_mut()).push((2, 'b'));
+            app.update();
+            let diffs = get_and_clear_output::<(u32, char)>(app.world_mut());
+            assert_eq!(
+                diffs[0],
                 VecDiff::InsertAt {
-                    index: 0,
-                    value: (0, 'z')
-                }  // Insert (0, 'z') at new sorted pos
-            ],
-            "Updating key did not produce correct move diffs."
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            vec![(0, 'z'), (2, 'b'), (3, 'C')],
-            "State after moving update is incorrect."
-        );
+                    index: 1,
+                    value: (2, 'b')
+                }
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd')]);
+
+            // --- 4. Test RemoveAt ---
+            source_vec.write(app.world_mut()).remove(1); // Removes (1, 'a')
+            app.update();
+            let diffs = get_and_clear_output::<(u32, char)>(app.world_mut());
+            assert_eq!(diffs[0], VecDiff::RemoveAt { index: 0 });
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![(2, 'b'), (3, 'c'), (4, 'd')]);
+
+            // --- 5. Test UpdateAt ---
+            // Case A: Update without changing sort order.
+            source_vec.write(app.world_mut()).set(0, (3, 'C')); // Was (3, 'c')
+            app.update();
+            let diffs = get_and_clear_output::<(u32, char)>(app.world_mut());
+            assert_eq!(diffs.len(), 1);
+            assert_eq!(
+                diffs[0],
+                VecDiff::UpdateAt {
+                    index: 1,
+                    value: (3, 'C')
+                }
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![(2, 'b'), (3, 'C'), (4, 'd')]);
+
+            // Case B: Update that changes sort order.
+            // Source is now [(3, 'C'), (4, 'd'), (2, 'b')]. Sorted is [(2, 'b'), (3, 'C'), (4, 'd')]
+            // Update (4, 'd') at source index 1 to (0, 'z').
+            // The old item was at sorted index 2. The new item should be at sorted index 0.
+            source_vec.write(app.world_mut()).set(1, (0, 'z'));
+            app.update();
+            let diffs = get_and_clear_output::<(u32, char)>(app.world_mut());
+            assert_eq!(diffs.len(), 2, "Update with sort change should be Remove+Insert.");
+            assert_eq!(
+                diffs,
+                vec![
+                    VecDiff::RemoveAt { index: 2 }, // Remove (4, 'd') from old sorted pos
+                    VecDiff::InsertAt {
+                        index: 0,
+                        value: (0, 'z')
+                    }  // Insert (0, 'z') at new sorted pos
+                ],
+                "Updating key did not produce correct move diffs."
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec![(0, 'z'), (2, 'b'), (3, 'C')],
+                "State after moving update is incorrect."
+            );
 
-        // --- 6. Test Move (in source) ---
-        // Source: [(3, 'C'), (0, 'z'), (2, 'b')] -> move 0 to 2 -> [(0, 'z'), (2, 'b'), (3, 'C')]
-        // Sorted output should not change at all.
-        source_vec.write().move_item(0, 2);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<(u32, char)>(app.world_mut());
-        assert!(diffs.is_empty(), "Moving in source should not affect sorted output.");
-        assert_eq!(current_state, vec![(0, 'z'), (2, 'b'), (3, 'C')]);
+            // --- 6. Test Move (in source) ---
+            // Source: [(3, 'C'), (0, 'z'), (2, 'b')] -> move 0 to 2 -> [(0, 'z'), (2, 'b'), (3, 'C')]
+            // Sorted output should not change at all.
+            source_vec.write(app.world_mut()).move_item(0, 2);
+            app.update();
+            let diffs = get_and_clear_output::<(u32, char)>(app.world_mut());
+            assert!(diffs.is_empty(), "Moving in source should not affect sorted output.");
+            assert_eq!(current_state, vec![(0, 'z'), (2, 'b'), (3, 'C')]);
+
+            // --- 7. Test Stability (Duplicate Keys) ---
+            source_vec.write(app.world_mut()).push((3, 'c'));
+            app.update();
+            apply_diffs(&mut current_state, get_and_clear_output::<(u32, char)>(app.world_mut()));
+            assert_eq!(
+                current_state,
+                vec![(0, 'z'), (2, 'b'), (3, 'C'), (3, 'c')],
+                "Stability with duplicate keys failed."
+            );
 
-        // --- 7. Test Stability (Duplicate Keys) ---
-        source_vec.write().push((3, 'c'));
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        apply_diffs(
-            &mut current_state,
-            &get_and_clear_output::<(u32, char)>(app.world_mut()),
-        );
-        assert_eq!(
-            current_state,
-            vec![(0, 'z'), (2, 'b'), (3, 'C'), (3, 'c')],
-            "Stability with duplicate keys failed."
-        );
+            // --- 8. Test Clear ---
+            source_vec.write(app.world_mut()).clear();
+            app.update();
+            let diffs = get_and_clear_output::<(u32, char)>(app.world_mut());
+            assert_eq!(diffs, vec![VecDiff::Clear]);
+            apply_diffs(&mut current_state, diffs);
+            assert!(current_state.is_empty());
 
-        // --- 8. Test Clear ---
-        source_vec.write().clear();
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<(u32, char)>(app.world_mut());
-        assert_eq!(diffs, vec![VecDiff::Clear]);
-        apply_diffs(&mut current_state, &diffs);
-        assert!(current_state.is_empty());
+            // --- 9. Cleanup ---
+            handle.cleanup(app.world_mut());
+        }
 
-        // --- 9. Cleanup ---
-        handle.cleanup(app.world_mut());
+        cleanup(true)
     }
 
     #[test]
     fn test_sort_by_cmp() {
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-        app.init_resource::<SignalVecOutput<i32>>();
+        {
+            // --- 1. Setup ---
+            let mut app = create_test_app();
+            app.init_resource::<SignalVecOutput<i32>>();
 
-        // The source vector, intentionally unsorted.
-        let source_vec = MutableVec::from(vec![5, 1, 4, -2, 3]);
+            // The source vector, intentionally unsorted.
+            let source_vec = MutableVecBuilder::from([5, 1, 4, -2, 3]).spawn(app.world_mut());
 
-        // The signal chain under test, using the convenience method.
-        let sorted_signal = source_vec.signal_vec().sort_by_cmp();
+            // The signal chain under test, using the convenience method.
+            let sorted_signal = source_vec.signal_vec().sort_by_cmp();
 
-        let handle = sorted_signal
-            .for_each(capture_signal_vec_output)
-            .register(app.world_mut());
+            let handle = sorted_signal
+                .for_each(capture_signal_vec_output)
+                .register(app.world_mut());
 
-        let mut current_state: Vec<i32> = vec![];
+            let mut current_state: Vec<i32> = vec![];
 
-        // --- 2. Test Initial State ---
-        app.update();
-        let diffs = get_and_clear_output::<i32>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Initial update should produce one Replace diff.");
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            vec![-2, 1, 3, 4, 5],
-            "Initial state is not correctly sorted by cmp."
-        );
+            // --- 2. Test Initial State ---
+            app.update();
+            let diffs = get_and_clear_output::<i32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Initial update should produce one Replace diff.");
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec![-2, 1, 3, 4, 5],
+                "Initial state is not correctly sorted by cmp."
+            );
 
-        // --- 3. Test Push ---
-        // Push an item that should be inserted in the middle.
-        source_vec.write().push(2);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<i32>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Push should produce one diff.");
-        assert_eq!(
-            diffs[0],
-            VecDiff::InsertAt { index: 2, value: 2 },
-            "Pushing 2 should insert at sorted index 2."
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(current_state, vec![-2, 1, 2, 3, 4, 5], "State after Push is incorrect.");
-
-        // --- 4. Test RemoveAt ---
-        // Remove '4' from the source vec.
-        // Source is now: `[5, 1, 4, -2, 3, 2]` -> remove at index 2 (`4`)
-        // Source becomes: `[5, 1, -2, 3, 2]`
-        // Sorted output before was: `[-2, 1, 2, 3, 4, 5]`
-        // The item '4' is at sorted index 4.
-        source_vec.write().remove(2);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<i32>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "RemoveAt should produce one diff.");
-        assert_eq!(
-            diffs[0],
-            VecDiff::RemoveAt { index: 4 },
-            "Removing 4 should remove at sorted index 4."
-        );
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            vec![-2, 1, 2, 3, 5],
-            "State after RemoveAt is incorrect."
-        );
+            // --- 3. Test Push ---
+            // Push an item that should be inserted in the middle.
+            source_vec.write(app.world_mut()).push(2);
+            app.update();
+            let diffs = get_and_clear_output::<i32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Push should produce one diff.");
+            assert_eq!(
+                diffs[0],
+                VecDiff::InsertAt { index: 2, value: 2 },
+                "Pushing 2 should insert at sorted index 2."
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(current_state, vec![-2, 1, 2, 3, 4, 5], "State after Push is incorrect.");
+
+            // --- 4. Test RemoveAt ---
+            // Remove '4' from the source vec.
+            // Source is now: `[5, 1, 4, -2, 3, 2]` -> remove at index 2 (`4`)
+            // Source becomes: `[5, 1, -2, 3, 2]`
+            // Sorted output before was: `[-2, 1, 2, 3, 4, 5]`
+            // The item '4' is at sorted index 4.
+            source_vec.write(app.world_mut()).remove(2);
+            app.update();
+            let diffs = get_and_clear_output::<i32>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "RemoveAt should produce one diff.");
+            assert_eq!(
+                diffs[0],
+                VecDiff::RemoveAt { index: 4 },
+                "Removing 4 should remove at sorted index 4."
+            );
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec![-2, 1, 2, 3, 5],
+                "State after RemoveAt is incorrect."
+            );
 
-        // --- 5. Test Clear ---
-        source_vec.write().clear();
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<i32>(app.world_mut());
-        assert_eq!(diffs, vec![VecDiff::Clear]);
-        apply_diffs(&mut current_state, &diffs);
-        assert!(current_state.is_empty(), "State after clear should be empty.");
+            // --- 5. Test Clear ---
+            source_vec.write(app.world_mut()).clear();
+            app.update();
+            let diffs = get_and_clear_output::<i32>(app.world_mut());
+            assert_eq!(diffs, vec![VecDiff::Clear]);
+            apply_diffs(&mut current_state, diffs);
+            assert!(current_state.is_empty(), "State after clear should be empty.");
 
-        // --- 6. Cleanup ---
-        handle.cleanup(app.world_mut());
+            // --- 6. Cleanup ---
+            handle.cleanup(app.world_mut());
+        }
+
+        cleanup(true)
     }
 
     #[test]
     fn test_sort_by_key() {
-        // --- 1. Setup ---
-        let mut app = create_test_app();
-
-        #[derive(Clone, Debug, PartialEq, Default)]
-        struct DataItem {
-            id: i32,
-            name: &'static str,
-        }
-
-        app.init_resource::<SignalVecOutput<DataItem>>();
-
-        let source_vec = MutableVec::from(vec![
-            DataItem { id: 3, name: "C" },
-            DataItem { id: 1, name: "A" },
-            DataItem { id: 4, name: "D" },
-        ]);
+        {
+            // --- 1. Setup ---
+            let mut app = create_test_app();
 
-        let key_system = |In(item): In<DataItem>| item.id;
-        let sorted_signal = source_vec.signal_vec().sort_by_key(key_system);
-        let handle = sorted_signal
-            .for_each(capture_signal_vec_output)
-            .register(app.world_mut());
+            #[derive(Clone, Debug, PartialEq, Default)]
+            struct DataItem {
+                id: i32,
+                name: &'static str,
+            }
 
-        let mut current_state: Vec<DataItem> = vec![];
+            app.init_resource::<SignalVecOutput<DataItem>>();
 
-        // --- 2. Test Initial State ---
-        app.update();
-        let diffs = get_and_clear_output::<DataItem>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Initial update should produce one Replace diff.");
-        apply_diffs(&mut current_state, &diffs);
-        assert_eq!(
-            current_state,
-            vec![
-                DataItem { id: 1, name: "A" },
+            let source_vec = MutableVecBuilder::from([
                 DataItem { id: 3, name: "C" },
-                DataItem { id: 4, name: "D" }
-            ],
-            "Initial state is not correctly sorted by key."
-        );
-
-        // --- 3. Test Push ---
-        source_vec.write().push(DataItem { id: 2, name: "B" });
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<DataItem>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Push should produce one diff.");
-        assert_eq!(
-            diffs[0],
-            VecDiff::InsertAt {
-                index: 1,
-                value: DataItem { id: 2, name: "B" }
-            }
-        );
-        apply_diffs(&mut current_state, &diffs);
-
-        // --- 4. Test RemoveAt ---
-        source_vec.write().remove(1); // Removes (1, 'A')
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<DataItem>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "RemoveAt should produce one diff.");
-        assert_eq!(diffs[0], VecDiff::RemoveAt { index: 0 });
-        apply_diffs(&mut current_state, &diffs);
-
-        // --- 5. Test UpdateAt ---
-        // Case A: Update without changing the key.
-        source_vec.write().set(0, DataItem { id: 3, name: "C-new" });
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<DataItem>(app.world_mut());
-        assert_eq!(diffs.len(), 1, "Update without key change should produce one diff.");
-        assert_eq!(
-            diffs[0],
-            VecDiff::UpdateAt {
-                index: 1,
-                value: DataItem { id: 3, name: "C-new" }
-            }
-        );
-        apply_diffs(&mut current_state, &diffs);
+                DataItem { id: 1, name: "A" },
+                DataItem { id: 4, name: "D" },
+            ])
+            .spawn(app.world_mut());
+
+            let key_system = |In(item): In<DataItem>| item.id;
+            let sorted_signal = source_vec.signal_vec().sort_by_key(key_system);
+            let handle = sorted_signal
+                .for_each(capture_signal_vec_output)
+                .register(app.world_mut());
+
+            let mut current_state: Vec<DataItem> = vec![];
+
+            // --- 2. Test Initial State ---
+            app.update();
+            let diffs = get_and_clear_output::<DataItem>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Initial update should produce one Replace diff.");
+            apply_diffs(&mut current_state, diffs);
+            assert_eq!(
+                current_state,
+                vec![
+                    DataItem { id: 1, name: "A" },
+                    DataItem { id: 3, name: "C" },
+                    DataItem { id: 4, name: "D" }
+                ],
+                "Initial state is not correctly sorted by key."
+            );
 
-        // Case B: Update that changes the key and sort order.
-        source_vec.write().set(1, DataItem { id: 0, name: "Z" }); // was (4, 'D')
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<DataItem>(app.world_mut());
-        assert_eq!(diffs.len(), 2, "Update with key change should be Remove+Insert.");
-        assert_eq!(
-            diffs,
-            vec![
-                VecDiff::RemoveAt { index: 2 },
+            // --- 3. Test Push ---
+            source_vec.write(app.world_mut()).push(DataItem { id: 2, name: "B" });
+            app.update();
+            let diffs = get_and_clear_output::<DataItem>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Push should produce one diff.");
+            assert_eq!(
+                diffs[0],
                 VecDiff::InsertAt {
-                    index: 0,
-                    value: DataItem { id: 0, name: "Z" }
+                    index: 1,
+                    value: DataItem { id: 2, name: "B" }
                 }
-            ],
-            "Updating key did not produce correct move diffs."
-        );
-        apply_diffs(&mut current_state, &diffs);
+            );
+            apply_diffs(&mut current_state, diffs);
+
+            // --- 4. Test RemoveAt ---
+            source_vec.write(app.world_mut()).remove(1); // Removes (1, 'A')
+            app.update();
+            let diffs = get_and_clear_output::<DataItem>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "RemoveAt should produce one diff.");
+            assert_eq!(diffs[0], VecDiff::RemoveAt { index: 0 });
+            apply_diffs(&mut current_state, diffs);
+
+            // --- 5. Test UpdateAt ---
+            // Case A: Update without changing the key.
+            source_vec
+                .write(app.world_mut())
+                .set(0, DataItem { id: 3, name: "C-new" });
+            app.update();
+            let diffs = get_and_clear_output::<DataItem>(app.world_mut());
+            assert_eq!(diffs.len(), 1, "Update without key change should produce one diff.");
+            assert_eq!(
+                diffs[0],
+                VecDiff::UpdateAt {
+                    index: 1,
+                    value: DataItem { id: 3, name: "C-new" }
+                }
+            );
+            apply_diffs(&mut current_state, diffs);
 
-        // --- 6. Test Move (in source) ---
-        source_vec.write().move_item(0, 2);
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<DataItem>(app.world_mut());
-        assert!(diffs.is_empty(), "Moving in source should not affect sorted output.");
+            // Case B: Update that changes the key and sort order.
+            source_vec.write(app.world_mut()).set(1, DataItem { id: 0, name: "Z" }); // was (4, 'D')
+            app.update();
+            let diffs = get_and_clear_output::<DataItem>(app.world_mut());
+            assert_eq!(diffs.len(), 2, "Update with key change should be Remove+Insert.");
+            assert_eq!(
+                diffs,
+                vec![
+                    VecDiff::RemoveAt { index: 2 },
+                    VecDiff::InsertAt {
+                        index: 0,
+                        value: DataItem { id: 0, name: "Z" }
+                    }
+                ],
+                "Updating key did not produce correct move diffs."
+            );
+            apply_diffs(&mut current_state, diffs);
+
+            // --- 6. Test Move (in source) ---
+            source_vec.write(app.world_mut()).move_item(0, 2);
+            app.update();
+            let diffs = get_and_clear_output::<DataItem>(app.world_mut());
+            assert!(diffs.is_empty(), "Moving in source should not affect sorted output.");
+
+            // --- 7. Test Stability (Duplicate Keys) ---
+            source_vec
+                .write(app.world_mut())
+                .push(DataItem { id: 3, name: "c-dup" });
+            app.update();
+            apply_diffs(&mut current_state, get_and_clear_output::<DataItem>(app.world_mut()));
+            assert_eq!(
+                current_state,
+                vec![
+                    DataItem { id: 0, name: "Z" },
+                    DataItem { id: 2, name: "B" },
+                    DataItem { id: 3, name: "C-new" },
+                    DataItem { id: 3, name: "c-dup" }
+                ],
+                "Stability with duplicate keys failed."
+            );
 
-        // --- 7. Test Stability (Duplicate Keys) ---
-        source_vec.write().push(DataItem { id: 3, name: "c-dup" });
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        apply_diffs(&mut current_state, &get_and_clear_output::<DataItem>(app.world_mut()));
-        assert_eq!(
-            current_state,
-            vec![
-                DataItem { id: 0, name: "Z" },
-                DataItem { id: 2, name: "B" },
-                DataItem { id: 3, name: "C-new" },
-                DataItem { id: 3, name: "c-dup" }
-            ],
-            "Stability with duplicate keys failed."
-        );
+            // --- 8. Test Clear ---
+            source_vec.write(app.world_mut()).clear();
+            app.update();
+            let diffs = get_and_clear_output::<DataItem>(app.world_mut());
+            assert_eq!(diffs, vec![VecDiff::Clear]);
+            apply_diffs(&mut current_state, diffs);
+            assert!(current_state.is_empty());
 
-        // --- 8. Test Clear ---
-        source_vec.write().clear();
-        source_vec.flush_into_world(app.world_mut());
-        app.update();
-        let diffs = get_and_clear_output::<DataItem>(app.world_mut());
-        assert_eq!(diffs, vec![VecDiff::Clear]);
-        apply_diffs(&mut current_state, &diffs);
-        assert!(current_state.is_empty());
+            // --- 9. Cleanup ---
+            handle.cleanup(app.world_mut());
+        }
 
-        // --- 9. Cleanup ---
-        handle.cleanup(app.world_mut());
+        cleanup(true)
     }
 
     /* #[test]
@@ -6929,7 +7010,6 @@ mod tests {
         // --- 2. Inner Vec Change: Push to `vec_a` ---
         // A push to the _first_ inner vector should insert at the correct global index.
         vec_a.write().push(12);
-        vec_a.flush_into_world(app.world_mut());
         app.update();
 
         let diffs = get_and_clear_output::<u32>(app.world_mut());
@@ -6939,13 +7019,12 @@ mod tests {
             VecDiff::InsertAt { index: 2, value: 12 },
             "Should insert at index 2 (end of vec_a's block)."
         );
-        apply_diffs(&mut current_state, &diffs);
+        apply_diffs(&mut current_state, diffs);
         assert_eq!(current_state, vec![10, 11, 12, 20]);
 
         // --- 3. Inner Vec Change: Push to `vec_b` ---
         // A push to the _second_ inner vector should insert at an offset index.
         vec_b.write().push(21);
-        vec_b.flush_into_world(app.world_mut());
         app.update();
 
         let diffs = get_and_clear_output::<u32>(app.world_mut());
@@ -6956,19 +7035,18 @@ mod tests {
             VecDiff::InsertAt { index: 4, value: 21 },
             "Should insert at index 4 (end of vec_b's block)."
         );
-        apply_diffs(&mut current_state, &diffs);
+        apply_diffs(&mut current_state, diffs);
         assert_eq!(current_state, vec![10, 11, 12, 20, 21]);
 
         // --- 4. Outer Vec Change: Remove `vec_b` ---
         // Removing an inner vector should remove its entire block of items.
         source_of_vecs.write().remove(1); // Removes vec_b
-        source_of_vecs.flush_into_world(app.world_mut());
         app.update();
 
         let diffs = get_and_clear_output::<u32>(app.world_mut());
         // The implementation should produce two RemoveAt diffs for vec_b's two items.
         assert_eq!(diffs.len(), 2, "Removing vec_b should produce 2 diffs.");
-        apply_diffs(&mut current_state, &diffs);
+        apply_diffs(&mut current_state, diffs);
         // The final state should no longer contain 20 or 21.
         assert_eq!(
             current_state,
@@ -6980,7 +7058,6 @@ mod tests {
         // --- 5. Cleanup Verification ---
         // Updates to the removed `vec_b` should now be ignored.
         vec_b.write().push(99);
-        vec_b.flush_into_world(app.world_mut());
         app.update();
         let diffs = get_and_clear_output::<u32>(app.world_mut());
         assert!(diffs.is_empty(), "Should ignore diffs from the removed vec_b.");
@@ -6988,13 +7065,12 @@ mod tests {
         // --- 6. Outer Vec Change: Push a new vector ---
         let vec_d = MutableVec::from([40u32, 41]);
         source_of_vecs.write().push(vec_d.signal_vec());
-        source_of_vecs.flush_into_world(app.world_mut());
         app.update();
 
         let diffs = get_and_clear_output::<u32>(app.world_mut());
         // Pushing a new inner vector should add its initial items to the end.
         assert_eq!(diffs.len(), 2, "Pushing new vec_d should produce 2 diffs.");
-        apply_diffs(&mut current_state, &diffs);
+        apply_diffs(&mut current_state, diffs);
         assert_eq!(
             current_state,
             vec![10, 11, 12, 40, 41],
@@ -7006,11 +7082,10 @@ mod tests {
         // Current state: [10, 11, 12, (empty), 40, 41].
         // Move vec_d (index 2) to the front (index 0).
         source_of_vecs.write().move_item(2, 0);
-        source_of_vecs.flush_into_world(app.world_mut());
         app.update();
 
         let diffs = get_and_clear_output::<u32>(app.world_mut());
-        apply_diffs(&mut current_state, &diffs);
+        apply_diffs(&mut current_state, diffs);
         assert_eq!(
             current_state,
             vec![40, 41, 10, 11, 12],
@@ -7020,39 +7095,14 @@ mod tests {
         // --- 8. Outer Vec Change: Clear ---
         // Clearing the outer vector should remove all items.
         source_of_vecs.write().clear();
-        source_of_vecs.flush_into_world(app.world_mut());
         app.update();
 
         let diffs = get_and_clear_output::<u32>(app.world_mut());
         assert_eq!(diffs.len(), 1, "Clear on outer vec should produce one diff.");
         assert_eq!(diffs[0], VecDiff::Clear, "Expected a Clear diff.");
-        apply_diffs(&mut current_state, &diffs);
+        apply_diffs(&mut current_state, diffs);
         assert!(current_state.is_empty(), "Final state should be empty after clear.");
 
         handle.cleanup(app.world_mut());
     } */
-
-    #[test]
-    fn test_mutable_vec_push_and_flush() {
-        let mut app = create_test_app();
-        app.init_resource::<SignalVecOutput<u32>>();
-        let mutable_vec = MutableVec::new();
-        let signal_handle = mutable_vec
-            .signal_vec()
-            .for_each(capture_signal_vec_output)
-            .register(app.world_mut());
-
-        // Initial flush (should be empty, no Replace diff)
-        app.update();
-        let initial_output = get_signal_vec_output::<u32>(app.world());
-        assert_eq!(initial_output.len(), 0);
-        mutable_vec.write().push(1u32);
-        mutable_vec.flush_into_world(app.world_mut());
-        app.update();
-        let output = get_signal_vec_output::<u32>(app.world());
-        assert_eq!(output.len(), 1);
-        assert_eq!(output[0], VecDiff::Push { value: 1 });
-        assert_eq!(mutable_vec.read().as_ref(), &[1]);
-        signal_handle.cleanup(app.world_mut());
-    }
 }
diff --git a/src/utils.rs b/src/utils.rs
index d3643c6..0dd1c26 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -1,3 +1,5 @@
+use core::ops::Deref;
+
 use bevy_ecs::prelude::*;
 use bevy_platform::sync::{Arc, OnceLock};
 #[doc(no_inline)]
@@ -9,6 +11,8 @@ pub use enclose::enclose as clone;
 #[derive(Default, Clone)]
 pub struct LazyEntity(Arc<OnceLock<Entity>>);
 
+const LAZY_ENTITY_GET_ERROR: &str = "EntityHolder does not contain an Entity";
+
 impl LazyEntity {
     #[allow(missing_docs)]
     pub fn new() -> Self {
@@ -22,7 +26,15 @@ impl LazyEntity {
 
     /// Get the [`Entity`], panicking if it was not set.
     pub fn get(&self) -> Entity {
-        self.0.get().copied().expect("EntityHolder does not contain an Entity")
+        self.0.get().copied().expect(LAZY_ENTITY_GET_ERROR)
+    }
+}
+
+impl Deref for LazyEntity {
+    type Target = Entity;
+
+    fn deref(&self) -> &Self::Target {
+        self.0.get().expect(LAZY_ENTITY_GET_ERROR)
     }
 }