update changelog

cache defaults/duplicates per chunk, use it for spawn/clone ops
add spawn/clone with defaults bmarks
2025-12-13 03:29:08 +07:00 · 2025-11-21 06:31:42 +07:00 · 2025-11-21 05:37:14 +07:00 · 2025-11-20 16:19:13 +07:00 · 2025-11-20 05:00:52 +07:00 · 2025-11-19 08:51:26 +07:00
27 changed files with 7150 additions and 3127 deletions
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,5 +1,5 @@
 {
-    "[json][jsonc][lua][markdown][yaml]": {
+    "[json][jsonc][lua][markdown][teal][yaml]": {
        "editor.formatOnSave": true,
        "files.insertFinalNewline": true,
        "files.trimFinalNewlines": true,
@@ -8,7 +8,6 @@
    "markdown.extension.toc.levels": "2..6",
    "markdown.extension.toc.omittedFromToc": {
        "README.md": [
-            "# Changelog",
            "# API Reference"
        ]
    }
--- a/README.md
+++ b/README.md
@@ -31,6 +31,7 @@
    - [Traits](#traits)
    - [Singletons](#singletons)
  - [Chunks](#chunks)
+    - [Entity Location](#entity-location)
  - [Structural Changes](#structural-changes)
    - [Spawning Entities](#spawning-entities)
    - [Entity Builders](#entity-builders)
@@ -47,6 +48,7 @@
    - [Fragment Hooks](#fragment-hooks)
    - [Unique Fragments](#unique-fragments)
    - [Explicit Fragments](#explicit-fragments)
+    - [Internal Fragments](#internal-fragments)
    - [Shared Components](#shared-components)
    - [Fragment Requirements](#fragment-requirements)
    - [Destruction Policies](#destruction-policies)
@@ -57,6 +59,13 @@
  - [Classes](#classes)
    - [Chunk](#chunk)
    - [Builder](#builder)
+- [Changelog](#changelog)
+  - [vX.X.X](#vxxx)
+  - [v1.4.0](#v140)
+  - [v1.3.0](#v130)
+  - [v1.2.0](#v120)
+  - [v1.1.0](#v110)
+  - [v1.0.0](#v100)
 - [License](#license)

 ## Introduction
@@ -147,11 +156,11 @@ function evolved.alive_any(...) end
 Sometimes (for debugging purposes, for example), it is necessary to extract the index and version from an identifier or to pack them back into an identifier. The [`evolved.pack`](#evolvedpack) and [`evolved.unpack`](#evolvedunpack) functions can be used for this purpose.

 ```lua
---@param index integer
---@param version integer
+---@param primary integer
+---@param secondary integer
 ---@return evolved.id id
 ---@nodiscard
-function evolved.pack(index, version) end
+function evolved.pack(primary, secondary) end

 ---@param id evolved.id
 ---@return integer primary
@@ -360,6 +369,43 @@ end
 -- Entity: 1048603, Health: 75, Stamina: 40
 ```

+#### Entity Location
+
+Sometimes it is useful to know which chunk a specific entity is in and its position within that chunk. The [`evolved.locate`](#evolvedlocate) function provides this information.
+
+```lua
+---@param entity evolved.entity
+---@return evolved.chunk? chunk
+---@return integer place
+function evolved.locate(entity) end
+```
+
+This function takes an entity and returns the chunk that contains it and the entity’s position (index) within that chunk. If the entity is not alive or is empty, the function returns `nil` for the chunk and `0` for the place.
+
+This is low-level functionality that you will rarely need. However, it can be useful in specific cases. For example, when you need to modify an entity’s component directly to avoid unnecessary [Deferred Operations](#deferred-operations) or [Fragment Hooks](#fragment-hooks), instead of using a higher-level function like [`evolved.set`](#evolvedset).
+
+```lua
+local evolved = require 'evolved'
+
+local health, stamina = evolved.id(2)
+
+local player = evolved.id()
+
+evolved.set(player, health, 100)
+evolved.set(player, stamina, 50)
+
+local player_chunk, player_place = evolved.locate(player)
+
+local health_components = player_chunk:components(health)
+local stamina_components = player_chunk:components(stamina)
+
+health_components[player_place] = 75
+stamina_components[player_place] = 42
+```
+
+> [!WARNING]
+> Do not use [`evolved.locate`](#evolvedlocate) to manipulate components directly unless you fully understand what you are doing. Because it is low-level functionality, incorrect use can lead to inconsistencies, as it bypasses the library’s safety checks and hook mechanisms. Use it only when you are certain it is safe and necessary.
+
 ### Structural Changes

 Every time we insert or remove a fragment from an entity, the entity will be migrated to a new chunk. This is done automatically by the library, of course. However, you should be aware of this because it can affect performance, especially if you have many fragments on the entity. This is called a `structural change`.
@@ -418,7 +464,7 @@ local health, stamina = evolved.id(2)
 local enemy = evolved.builder()
    :set(health, 100)
    :set(stamina, 50)
-    :spawn()
+    :build()
 ```

 Builders can be reused, so you can create a builder with a specific set of fragments and components and then use it to spawn multiple entities with the same fragments and components.
@@ -459,16 +505,16 @@ local evolved = require 'evolved'

 local health = evolved.builder()
    :name('health')
-    :spawn()
+    :build()

 local stamina = evolved.builder()
    :name('stamina')
-    :spawn()
+    :build()

 local player = evolved.builder()
    :set(health, 100)
    :set(stamina, 50)
-    :spawn()
+    :build()

 for fragment, component in evolved.each(player) do
    print(string.format('Fragment (%s) has value %d',
@@ -557,7 +603,7 @@ The builder interface can be used to create queries too. It is more convenient t
 local query = evolved.builder()
    :include(health, poisoned)
    :exclude(resistant)
-    :spawn()
+    :build()
 ```

 We don't have to set both [`evolved.INCLUDES`](#evolvedincludes) and [`evolved.EXCLUDES`](#evolvedexcludes) fragments, we can even do it without filters at all, then the query will match all chunks in the world.
@@ -599,6 +645,9 @@ function evolved.defer() end

 ---@return boolean committed
 function evolved.commit() end
+
+---@return boolean cancelled
+function evolved.cancel() end
 ```

 The [`evolved.defer`](#evolveddefer) function starts a deferred scope. This means that all changes made inside the scope will be queued and applied after leaving the scope. The [`evolved.commit`](#evolvedcommit) function closes the last deferred scope and applies all queued changes. These functions can be nested, so you can start a new deferred scope inside an existing one. The [`evolved.commit`](#evolvedcommit) function will apply all queued changes only when the last deferred scope is closed.
@@ -611,7 +660,7 @@ local health, poisoned = evolved.id(2)
 local player = evolved.builder()
    :set(health, 100)
    :set(poisoned, true)
-    :spawn()
+    :build()

 -- start a deferred scope
 evolved.defer()
@@ -629,6 +678,34 @@ evolved.commit()
 assert(not evolved.has(player, poisoned))
 ```

+The [`evolved.cancel`](#evolvedcancel) function can be used to cancel all queued changes in the current deferred scope. This is useful if you want to discard all changes made inside the scope and revert to the previous state on an error or some other condition.
+
+```lua
+local evolved = require 'evolved'
+
+local health, poisoned = evolved.id(2)
+
+local player = evolved.builder()
+    :set(health, 100)
+    :set(poisoned, true)
+    :build()
+
+-- start a deferred scope
+evolved.defer()
+
+-- this removal will be queued, not applied immediately
+evolved.remove(player, poisoned)
+
+-- the player still has the poisoned fragment inside the deferred scope
+assert(evolved.has(player, poisoned))
+
+-- cancel the deferred operations
+evolved.cancel()
+
+-- the poisoned fragment is still there
+assert(evolved.has(player, poisoned))
+```
+
 #### Batch Operations

 The library provides a set of functions for batch operations. These functions are used to perform modifying operations on multiple chunks at once. This is very useful for performance reasons.
@@ -659,7 +736,7 @@ local destroying_mark = evolved.id()

 local destroying_mark_query = evolved.builder()
    :include(destroying_mark)
-    :spawn()
+    :build()

 -- destroy all entities with the destroying_mark fragment
 evolved.batch_destroy(destroying_mark_query)
@@ -681,7 +758,7 @@ local health, max_health = evolved.id(2)

 local query = evolved.builder()
    :include(health, max_health)
-    :spawn()
+    :build()

 local system = evolved.builder()
    :query(query)
@@ -694,7 +771,7 @@ local system = evolved.builder()
                health_components[i] + 1,
                max_health_components[i])
        end
-    end):spawn()
+    end):build()
 ```

 The [`evolved.process`](#evolvedprocess) function is used to process systems. It takes systems as arguments and executes them in the order they were passed.
@@ -721,7 +798,7 @@ local system = evolved.builder()
                health_components[i] - 1,
                0)
        end
-    end):spawn()
+    end):build()

 evolved.process(system)
 ```
@@ -740,7 +817,7 @@ local velocity_x, velocity_y = evolved.id(2)
 local physical_body_query = evolved.builder()
    :include(position_x, position_y)
    :include(velocity_x, velocity_y)
-    :spawn()
+    :build()

 local physics_group = evolved.id()

@@ -755,7 +832,7 @@ evolved.builder()
            vx[i] = vx[i] + gravity_x
            vy[i] = vy[i] + gravity_y
        end
-    end):spawn()
+    end):build()

 evolved.builder()
    :group(physics_group)
@@ -771,7 +848,7 @@ evolved.builder()
            px[i] = px[i] + vx[i]
            py[i] = py[i] + vy[i]
        end
-    end):spawn()
+    end):build()

 evolved.process(physics_group)
 ```
@@ -788,7 +865,7 @@ local system = evolved.builder()
    :epilogue(function()
        print('Epilogue')
    end)
-    :spawn()
+    :build()

 evolved.process(system)
 ```
@@ -830,7 +907,7 @@ local evolved = require 'evolved'
 local health = evolved.builder()
    :on_set(function(entity, fragment, component)
        print('health set to ' .. component)
-    end):spawn()
+    end):build()

 local player = evolved.id()
 evolved.set(player, health, 100) -- prints "health set to 100"
@@ -839,6 +916,9 @@ evolved.set(player, health, 200) -- prints "health set to 200"

 Use [`evolved.ON_SET`](#evolvedon_set) for callbacks on fragment insert or override, [`evolved.ON_ASSIGN`](#evolvedon_assign) for overrides, and [`evolved.ON_INSERT`](#evolvedon_insert)/[`evolved.ON_REMOVE`](#evolvedon_remove) for insertions or removals.

+> [!NOTE]
+> Because fragments marked with [`evolved.TAG`](#evolvedtag) (also called [Fragment Tags](#fragment-tags)) have no components, their [`evolved.ON_SET`](#evolvedon_set) hooks are invoked only when the tag is inserted, not when it is overridden, as there is nothing to override. Their [`evolved.ON_ASSIGN`](#evolvedon_assign) hooks are never invoked for such tags for the same reason.
+
 #### Unique Fragments

 Some fragments should not be cloned when cloning entities. For example, `evolved.lua` has a special fragment called `evolved.PREFAB`, which marks entities used as sources for cloning. This fragment should not be present on the cloned entities. To prevent a fragment from being cloned, mark it as unique using the [`evolved.UNIQUE`](#evolvedunique) fragment trait. This ensures the fragment will not be copied when cloning entities.
@@ -852,7 +932,7 @@ local enemy_prefab = evolved.builder()
    :prefab()
    :set(health, 100)
    :set(stamina, 50)
-    :spawn()
+    :build()

 local enemy_clone = evolved.clone(enemy_prefab)

@@ -874,18 +954,22 @@ local evolved = require 'evolved'

 local enemy_tag = evolved.builder()
    :tag()
-    :spawn()
+    :build()

 local only_enabled_enemies = evolved.builder()
    :include(enemy_tag)
-    :spawn()
+    :build()

 local all_enemies_including_disabled = evolved.builder()
    :include(enemy_tag)
    :include(evolved.DISABLED)
-    :spawn()
+    :build()
 ```

+#### Internal Fragments
+
+All predefined fragments provided by the library are marked as internal with the [`evolved.INTERNAL`](#evolvedinternal) trait. Because [`evolved.INTERNAL`](#evolvedinternal) is itself marked as [`evolved.EXPLICIT`](#evolvedexplicit), these fragments are hidden from queries by default. This prevents accidental use of internal fragments in user code and helps distinguish them from user-defined fragments.
+
 #### Shared Components

 Often, we want to store components as tables, and by default, these tables will be shared between entities. This means that if you modify the table in one entity, it will be modified in all entities that share this table. Sometimes this is what we want. For example, when we want to share a configuration or some resource between entities. But in other cases, we want each entity to have its own copy of the table. For example, if we want to store the position of an entity as a table, we don't want to share this table with other entities. Yes, we can copy the table manually, but the library provides a little bit of syntactic sugar for this.
@@ -899,11 +983,11 @@ local position = evolved.id()

 local enemy1 = evolved.builder()
    :set(position, initial_position)
-    :spawn()
+    :build()

 local enemy2 = evolved.builder()
    :set(position, initial_position)
-    :spawn()
+    :build()

 -- the enemy1 and enemy2 share the same table,
 -- and that's definitely not what we want in this case
@@ -928,15 +1012,15 @@ end
 local position = evolved.builder()
    :default(vector2(0, 0))
    :duplicate(vector2_duplicate)
-    :spawn()
+    :build()

 local enemy1 = evolved.builder()
    :set(position)
-    :spawn()
+    :build()

 local enemy2 = evolved.builder()
    :set(position)
-    :spawn()
+    :build()

 -- the enemy1 and enemy2 have different tables now
 assert(evolved.get(enemy1, position) ~= evolved.get(enemy2, position))
@@ -952,21 +1036,21 @@ local evolved = require 'evolved'
 local position = evolved.builder()
    :default(vector2(0, 0))
    :duplicate(vector2_duplicate)
-    :spawn()
+    :build()

 local velocity = evolved.builder()
    :default(vector2(0, 0))
    :duplicate(vector2_duplicate)
-    :spawn()
+    :build()

 local physical = evolved.builder()
    :tag()
    :require(position, velocity)
-    :spawn()
+    :build()

 local enemy = evolved.builder()
    :set(physical)
-    :spawn()
+    :build()

 assert(evolved.has_all(enemy, position, velocity))
 ```
@@ -980,11 +1064,11 @@ local evolved = require 'evolved'

 local world = evolved.builder()
    :tag()
-    :spawn()
+    :build()

 local entity = evolved.builder()
    :set(world)
-    :spawn()
+    :build()

 -- destroy the world fragment that is attached to the entity
 evolved.destroy(world)
@@ -1005,11 +1089,11 @@ local evolved = require 'evolved'
 local world = evolved.builder()
    :tag()
    :destruction_policy(evolved.DESTRUCTION_POLICY_DESTROY_ENTITY)
-    :spawn()
+    :build()

 local entity = evolved.builder()
    :set(world)
-    :spawn()
+    :build()

 -- destroy the world fragment that is attached to the entity
 evolved.destroy(world)
@@ -1040,7 +1124,7 @@ execute :: {chunk, entity[], integer}
 prologue :: {}
 epilogue :: {}

-set_hook :: {entity, fragment, component, component?}
+set_hook :: {entity, fragment, component, component}
 assign_hook :: {entity, fragment, component, component}
 insert_hook :: {entity, fragment, component}
 remove_hook :: {entity, fragment, component}
@@ -1097,13 +1181,17 @@ id :: integer? -> id...
 name :: id... -> string...

 pack :: integer, integer -> id
-unpack :: id -> integer, integer, integer
+unpack :: id -> integer, integer

 defer :: boolean
 commit :: boolean
+cancel :: boolean

 spawn :: <fragment, component>? -> entity
-clone :: entity -> <fragment, component>? -> entity
+multi_spawn :: integer, <fragment, component>? -> entity[], integer
+
+clone :: entity, <fragment, component>? -> entity
+multi_clone :: integer, entity, <fragment, component>? -> entity[], integer

 alive :: entity -> boolean
 alive_all :: entity... -> boolean
@@ -1132,6 +1220,8 @@ batch_destroy :: query... -> ()
 each :: entity -> {each_state? -> fragment?, component?}, each_state?
 execute :: query -> {execute_state? -> chunk?, entity[]?, integer?}, execute_state?

+locate :: entity -> chunk?, integer
+
 process :: system... -> ()

 debug_mode :: boolean -> ()
@@ -1162,8 +1252,14 @@ chunk_mt:components :: fragment... -> storage...
 ```
 builder :: builder

+builder_mt:build :: entity? -> entity
+builder_mt:multi_build :: integer, entity? -> entity[], integer
+
 builder_mt:spawn :: entity
+builder_mt:multi_spawn :: integer -> entity[], integer
+
 builder_mt:clone :: entity -> entity
+builder_mt:multi_clone :: integer, entity -> entity[], integer

 builder_mt:has :: fragment -> boolean
 builder_mt:has_all :: fragment... -> boolean
@@ -1192,7 +1288,7 @@ builder_mt:include :: fragment... -> builder
 builder_mt:exclude :: fragment... -> builder
 builder_mt:require :: fragment... -> builder

-builder_mt:on_set :: {entity, fragment, component, component?} -> builder
+builder_mt:on_set :: {entity, fragment, component, component} -> builder
 builder_mt:on_assign :: {entity, fragment, component, component} -> builder
 builder_mt:on_insert :: {entity, fragment, component} -> builder
 builder_mt:on_remove :: {entity, fragment} -> builder
@@ -1208,26 +1304,48 @@ builder_mt:epilogue :: {} -> builder
 builder_mt:destruction_policy :: id -> builder
 ```

-## License
+## Changelog

-`evolved.lua` is licensed under the [MIT License][license]. For more details, see the [LICENSE.md](./LICENSE.md) file in the repository.
+### vX.X.X

-# Changelog
+- The spawn and clone operations with defaults have been significantly optimized
+- Added basic [Teal](https://github.com/teal-language) type definitions, thanks to [@p0sel0k](https://github.com/p0sel0k)

-## vX.X.X
+### v1.4.0
+
+- Improved query execution performance by caching some internal calculations
+- Added the universal [`builder.build`](#evolvedbuilder_mtbuild) and [`builder.multi_build`](#evolvedbuilder_mtmulti_build) methods that can be used to spawn or clone entities depending on the method arguments
+- [`evolved.ON_REMOVE`](#evolvedon_remove) hooks are now invoked before the fragment is actually removed from the entity
+
+### v1.3.0
+
+- Added the new [`evolved.cancel`](#evolvedcancel) function
+- Added the new [`evolved.locate`](#evolvedlocate) function
+- The internal garbage collector now collects more garbage
+- Improved system processing debugging experience with stack traces on errors
+- [`SET/ASSIGN hooks`](#fragment-hooks) are not invoked for tags on override operations anymore
+- Improved performance of cloning prefabs with many [`Unique Fragments`](#unique-fragments)
+- Improved performance of builders that are used for spawning multiple times
+
+### v1.2.0

 - Added the new [`evolved.name`](#evolvedname-1) function
+- Added the new [`evolved.multi_spawn`](#evolvedmulti_spawn) and [`evolved.multi_clone`](#evolvedmulti_clone) functions
 - Added the new [`evolved.INTERNAL`](#evolvedinternal) fragment trait

-## v1.1.0
+### v1.1.0

 - [`Systems`](#systems) can be queries themselves now
 - Added the new [`evolved.REQUIRES`](#evolvedrequires) fragment trait

-## v1.0.0
+### v1.0.0

 - Initial release

+## License
+
+`evolved.lua` is licensed under the [MIT License][license]. For more details, see the [LICENSE.md](./LICENSE.md) file in the repository.
+
 # API Reference

 ## Predefs
@@ -1303,11 +1421,11 @@ function evolved.name(...) end
 ### `evolved.pack`

 ```lua
---@param index integer
---@param version integer
+---@param primary integer
+---@param secondary integer
 ---@return evolved.id id
 ---@nodiscard
-function evolved.pack(index, version) end
+function evolved.pack(primary, secondary) end
 ```

 ### `evolved.unpack`
@@ -1334,23 +1452,51 @@ function evolved.defer() end
 function evolved.commit() end
 ```

+### `evolved.cancel`
+
+```lua
+---@return boolean cancelled
+function evolved.cancel() end
+```
+
 ### `evolved.spawn`

 ```lua
 ---@param components? table<evolved.fragment, evolved.component>
---@return evolved.entity
+---@return evolved.entity entity
 function evolved.spawn(components) end
 ```

+### `evolved.multi_spawn`
+
+```lua
+---@param entity_count integer
+---@param components? table<evolved.fragment, evolved.component>
+---@return evolved.entity[] entity_list
+---@return integer entity_count
+function evolved.multi_spawn(entity_count, components) end
+```
+
 ### `evolved.clone`

 ```lua
 ---@param prefab evolved.entity
 ---@param components? table<evolved.fragment, evolved.component>
---@return evolved.entity
+---@return evolved.entity entity
 function evolved.clone(prefab, components) end
 ```

+### `evolved.multi_clone`
+
+```lua
+---@param entity_count integer
+---@param prefab evolved.entity
+---@param components? table<evolved.fragment, evolved.component>
+---@return evolved.entity[] entity_list
+---@return integer entity_count
+function evolved.multi_clone(entity_count, prefab, components) end
+```
+
 ### `evolved.alive`

 ```lua
@@ -1527,6 +1673,16 @@ function evolved.each(entity) end
 function evolved.execute(query) end
 ```

+### `evolved.locate`
+
+```lua
+---@param entity evolved.entity
+---@return evolved.chunk? chunk
+---@return integer place
+---@nodiscard
+function evolved.locate(entity) end
+```
+
 ### `evolved.process`

 ```lua
@@ -1643,21 +1799,58 @@ function evolved.chunk_mt:components(...) end
 function evolved.builder() end
 ```

+#### `evolved.builder_mt:build`
+
+```lua
+---@param prefab? evolved.entity
+---@return evolved.entity entity
+function evolved.builder_mt:build(prefab) end
+```
+
+### `evolved.builder_mt:multi_build`
+
+```lua
+---@param entity_count integer
+---@param prefab? evolved.entity
+---@return evolved.entity[] entity_list
+---@return integer entity_count
+function evolved.builder_mt:multi_build(entity_count, prefab) end
+```
+
 #### `evolved.builder_mt:spawn`

 ```lua
---@return evolved.entity
+---@return evolved.entity entity
 function evolved.builder_mt:spawn() end
 ```

+#### `evolved.builder_mt:multi_spawn`
+
+```lua
+---@param entity_count integer
+---@return evolved.entity[] entity_list
+---@return integer entity_count
+function evolved.builder_mt:multi_spawn(entity_count) end
+```
+
 #### `evolved.builder_mt:clone`

 ```lua
 ---@param prefab evolved.entity
---@return evolved.entity
+---@return evolved.entity entity
 function evolved.builder_mt:clone(prefab) end
 ```

+#### `evolved.builder_mt:multi_clone`
+
+```lua
+---@param entity_count integer
+---@param prefab evolved.entity
+---@return evolved.entity[] entity_list
+---@return integer entity_count
+function evolved.builder_mt:multi_clone(entity_count, prefab) end
+```
+
 #### `evolved.builder_mt:has`

 ```lua
@@ -1757,7 +1950,7 @@ function evolved.builder_mt:internal() end
 #### `evolved.builder_mt:default`

 ```lua
---@param default evolved.component
+---@param default evolved.default
 ---@return evolved.builder builder
 function evolved.builder_mt:default(default) end
 ```
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -1,20 +0,0 @@
-# Roadmap
-
-## Backlog
-
- Improve the performance of required fragments by caching first-level required chunks.
- Improve the performance of builders that are used multiple times by caching hint chunks.
- Queries can cache major chunks to avoid finding them every time.
- Add multi-spawn to the builder to spawn multiple entities at once.
- Add a function to shrink storages to free unused memory.
- observers and events
- add INDEX fragment trait
- use compact prefix-tree for chunks
- optional ffi component storages
- add EXCLUSIVE fragment trait
-
-## Thoughts
-
- We can return deferred status from modifying operations and spawn/clone methods.
- Should we make one builder:build method instead of :spawn and :clone?
- Should we cache the result of without_unique_fragments to clone faster?
--- a/develop/GUIDES.md
+++ b/develop/GUIDES.md
--- a/develop/ROADMAP.md
+++ b/develop/ROADMAP.md
@@ -0,0 +1,18 @@
+# Roadmap
+
+## Backlog
+
+- observers and events
+- add INDEX fragment trait
+- use compact prefix-tree for chunks
+- optional ffi component storages
+
+## Thoughts
+
+- We can return deferred status from modifying operations and spawn/clone methods.
+- We should have a way to not copy components on deferred spawn/clone.
+
+## Known Issues
+
+- Required fragments are slower than they should be
+- Errors in hooks are cannot be handled properly right now
--- a/develop/all.lua
+++ b/develop/all.lua
@@ -1,19 +1,30 @@
 require 'develop.samples.systems'

+require 'develop.testing.build_tests'
+require 'develop.testing.cancel_tests'
+require 'develop.testing.clone_tests'
+require 'develop.testing.locate_tests'
+require 'develop.testing.main_tests'
+require 'develop.testing.multi_spawn_tests'
 require 'develop.testing.name_tests'
 require 'develop.testing.requires_fragment_tests'
+require 'develop.testing.spawn_tests'
 require 'develop.testing.system_as_query_tests'

-require 'develop.untests'
-
-require 'develop.unbench'
-require 'develop.usbench'
+require 'develop.benchmarks.clone_bmarks'
+require 'develop.benchmarks.common_bmarks'
+require 'develop.benchmarks.migration_bmarks'
+require 'develop.benchmarks.process_bmarks'
+require 'develop.benchmarks.spawn_bmarks'
+require 'develop.benchmarks.table_bmarks'

 local basics = require 'develop.basics'

 print '----------------------------------------'
 basics.describe_fuzz 'develop.fuzzing.destroy_fuzz'
 print '----------------------------------------'
+basics.describe_fuzz 'develop.fuzzing.execute_fuzz'
+print '----------------------------------------'
 basics.describe_fuzz 'develop.fuzzing.batch_destroy_fuzz'
 print '----------------------------------------'
 basics.describe_fuzz 'develop.fuzzing.explicit_fuzz'
--- a/develop/benchmarks/clone_bmarks.lua
+++ b/develop/benchmarks/clone_bmarks.lua
@@ -0,0 +1,532 @@
+local evo = require 'evolved'
+local basics = require 'develop.basics'
+
+evo.debug_mode(false)
+
+local N = 1000
+
+local F1, F2, F3, F4, F5 = evo.id(5)
+local D1, D2, D3, D4, D5 = evo.id(5)
+
+evo.set(D1, evo.DEFAULT, true)
+evo.set(D2, evo.DEFAULT, true)
+evo.set(D3, evo.DEFAULT, true)
+evo.set(D4, evo.DEFAULT, true)
+evo.set(D5, evo.DEFAULT, true)
+
+evo.set(D1, evo.DUPLICATE, function(v) return not v end)
+evo.set(D2, evo.DUPLICATE, function(v) return not v end)
+evo.set(D3, evo.DUPLICATE, function(v) return not v end)
+evo.set(D4, evo.DUPLICATE, function(v) return not v end)
+evo.set(D5, evo.DUPLICATE, function(v) return not v end)
+
+local QF1 = evo.builder():include(F1):spawn()
+local QD1 = evo.builder():include(D1):spawn()
+
+local RF1 = evo.builder():require(F1):spawn()
+local RF123 = evo.builder():require(F1, F2, F3):spawn()
+local RF12345 = evo.builder():require(F1, F2, F3, F4, F5):spawn()
+
+local RD1 = evo.builder():require(D1):spawn()
+local RD123 = evo.builder():require(D1, D2, D3):spawn()
+local RD12345 = evo.builder():require(D1, D2, D3, D4, D5):spawn()
+
+print '----------------------------------------'
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Simple Clone | %d entities with 1 component', N),
+    function()
+        local clone = evo.clone
+
+        local prefab = evo.spawn { [F1] = true }
+
+        for _ = 1, N do
+            clone(prefab)
+        end
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Simple Defer Clone | %d entities with 1 component', N),
+    function()
+        local clone = evo.clone
+
+        local prefab = evo.spawn { [F1] = true }
+
+        evo.defer()
+        for _ = 1, N do
+            clone(prefab)
+        end
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Simple Clone With Defaults | %d entities with 1 component', N),
+    function()
+        local clone = evo.clone
+
+        local prefab = evo.spawn { [D1] = true }
+
+        for _ = 1, N do
+            clone(prefab)
+        end
+
+        evo.batch_destroy(QD1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Simple Clone | %d entities with 3 components', N),
+    function()
+        local clone = evo.clone
+
+        local prefab = evo.spawn { [F1] = true, [F2] = true, [F3] = true }
+
+        for _ = 1, N do
+            clone(prefab)
+        end
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Simple Defer Clone | %d entities with 3 components', N),
+    function()
+        local clone = evo.clone
+
+        local prefab = evo.spawn { [F1] = true, [F2] = true, [F3] = true }
+
+        evo.defer()
+        for _ = 1, N do
+            clone(prefab)
+        end
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Simple Clone With Defaults | %d entities with 3 components', N),
+    function()
+        local clone = evo.clone
+
+        local prefab = evo.spawn { [D1] = true, [D2] = true, [D3] = true }
+
+        for _ = 1, N do
+            clone(prefab)
+        end
+
+        evo.batch_destroy(QD1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Simple Clone | %d entities with 5 components', N),
+    function()
+        local clone = evo.clone
+
+        local prefab = evo.spawn { [F1] = true, [F2] = true, [F3] = true, [F4] = true, [F5] = true }
+
+        for _ = 1, N do
+            clone(prefab)
+        end
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Simple Defer Clone | %d entities with 5 components', N),
+    function()
+        local clone = evo.clone
+
+        local prefab = evo.spawn { [F1] = true, [F2] = true, [F3] = true, [F4] = true, [F5] = true }
+
+        evo.defer()
+        for _ = 1, N do
+            clone(prefab)
+        end
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Simple Clone With Defaults | %d entities with 5 components', N),
+    function()
+        local clone = evo.clone
+
+        local prefab = evo.spawn { [D1] = true, [D2] = true, [D3] = true, [D4] = true, [D5] = true }
+
+        for _ = 1, N do
+            clone(prefab)
+        end
+
+        evo.batch_destroy(QD1)
+    end)
+
+print '----------------------------------------'
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Simple Clone | %d entities with 1 required component', N),
+    function()
+        local clone = evo.clone
+
+        local prefab = evo.spawn { [RF1] = true }
+
+        for _ = 1, N do
+            clone(prefab)
+        end
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Simple Defer Clone | %d entities with 1 required component', N),
+    function()
+        local clone = evo.clone
+
+        local prefab = evo.spawn { [RF1] = true }
+
+        evo.defer()
+        for _ = 1, N do
+            clone(prefab)
+        end
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Simple Clone With Defaults | %d entities with 1 required component', N),
+    function()
+        local clone = evo.clone
+
+        local prefab = evo.spawn { [RD1] = true }
+
+        for _ = 1, N do
+            clone(prefab)
+        end
+
+        evo.batch_destroy(QD1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Simple Clone | %d entities with 3 required components', N),
+    function()
+        local clone = evo.clone
+
+        local prefab = evo.spawn { [RF123] = true }
+
+        for _ = 1, N do
+            clone(prefab)
+        end
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Simple Defer Clone | %d entities with 3 required components', N),
+    function()
+        local clone = evo.clone
+
+        local prefab = evo.spawn { [RF123] = true }
+
+        evo.defer()
+        for _ = 1, N do
+            clone(prefab)
+        end
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Simple Clone With Defaults | %d entities with 3 required components', N),
+    function()
+        local clone = evo.clone
+
+        local prefab = evo.spawn { [RD123] = true }
+
+        for _ = 1, N do
+            clone(prefab)
+        end
+
+        evo.batch_destroy(QD1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Simple Clone | %d entities with 5 required components', N),
+    function()
+        local clone = evo.clone
+
+        local prefab = evo.spawn { [RF12345] = true }
+
+        for _ = 1, N do
+            clone(prefab)
+        end
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Simple Defer Clone | %d entities with 5 required components', N),
+    function()
+        local clone = evo.clone
+
+        local prefab = evo.spawn { [RF12345] = true }
+
+        evo.defer()
+        for _ = 1, N do
+            clone(prefab)
+        end
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Simple Clone With Defaults | %d entities with 5 required components', N),
+    function()
+        local clone = evo.clone
+
+        local prefab = evo.spawn { [RD12345] = true }
+
+        for _ = 1, N do
+            clone(prefab)
+        end
+
+        evo.batch_destroy(QD1)
+    end)
+
+print '----------------------------------------'
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Multi Clone | %d entities with 1 component', N),
+    function()
+        local multi_clone = evo.multi_clone
+
+        local prefab = evo.spawn { [F1] = true }
+
+        multi_clone(N, prefab)
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Multi Defer Clone | %d entities with 1 component', N),
+    function()
+        local multi_clone = evo.multi_clone
+
+        local prefab = evo.spawn { [F1] = true }
+
+        evo.defer()
+        multi_clone(N, prefab)
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Multi Clone With Defaults | %d entities with 1 component', N),
+    function()
+        local multi_clone = evo.multi_clone
+
+        local prefab = evo.spawn { [D1] = true }
+
+        multi_clone(N, prefab)
+
+        evo.batch_destroy(QD1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Multi Clone | %d entities with 3 components', N),
+    function()
+        local multi_clone = evo.multi_clone
+
+        local prefab = evo.spawn { [F1] = true, [F2] = true, [F3] = true }
+
+        multi_clone(N, prefab)
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Multi Defer Clone | %d entities with 3 components', N),
+    function()
+        local multi_clone = evo.multi_clone
+
+        local prefab = evo.spawn { [F1] = true, [F2] = true, [F3] = true }
+
+        evo.defer()
+        multi_clone(N, prefab)
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Multi Clone With Defaults | %d entities with 3 components', N),
+    function()
+        local multi_clone = evo.multi_clone
+
+        local prefab = evo.spawn { [D1] = true, [D2] = true, [D3] = true }
+
+        multi_clone(N, prefab)
+
+        evo.batch_destroy(QD1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Multi Clone | %d entities with 5 components', N),
+    function()
+        local multi_clone = evo.multi_clone
+
+        local prefab = evo.spawn { [F1] = true, [F2] = true, [F3] = true, [F4] = true, [F5] = true }
+
+        multi_clone(N, prefab)
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Multi Defer Clone | %d entities with 5 components', N),
+    function()
+        local multi_clone = evo.multi_clone
+
+        local prefab = evo.spawn { [F1] = true, [F2] = true, [F3] = true, [F4] = true, [F5] = true }
+
+        evo.defer()
+        multi_clone(N, prefab)
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Multi Clone With Defaults | %d entities with 5 components', N),
+    function()
+        local multi_clone = evo.multi_clone
+
+        local prefab = evo.spawn { [D1] = true, [D2] = true, [D3] = true, [D4] = true, [D5] = true }
+
+        multi_clone(N, prefab)
+
+        evo.batch_destroy(QD1)
+    end)
+
+print '----------------------------------------'
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Multi Clone | %d entities with 1 required component', N),
+    function()
+        local multi_clone = evo.multi_clone
+
+        local prefab = evo.spawn { [RF1] = true }
+
+        multi_clone(N, prefab)
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Multi Defer Clone | %d entities with 1 required component', N),
+    function()
+        local multi_clone = evo.multi_clone
+
+        local prefab = evo.spawn { [RF1] = true }
+
+        evo.defer()
+        multi_clone(N, prefab)
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Multi Clone With Defaults | %d entities with 1 required component', N),
+    function()
+        local multi_clone = evo.multi_clone
+
+        local prefab = evo.spawn { [RD1] = true }
+
+        multi_clone(N, prefab)
+
+        evo.batch_destroy(QD1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Multi Clone | %d entities with 3 required components', N),
+    function()
+        local multi_clone = evo.multi_clone
+
+        local prefab = evo.spawn { [RF123] = true }
+
+        multi_clone(N, prefab)
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Multi Defer Clone | %d entities with 3 required components', N),
+    function()
+        local multi_clone = evo.multi_clone
+
+        local prefab = evo.spawn { [RF123] = true }
+
+        evo.defer()
+        multi_clone(N, prefab)
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Multi Clone With Defaults | %d entities with 3 required components', N),
+    function()
+        local multi_clone = evo.multi_clone
+
+        local prefab = evo.spawn { [RD123] = true }
+
+        multi_clone(N, prefab)
+
+        evo.batch_destroy(QD1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Multi Clone | %d entities with 5 required components', N),
+    function()
+        local multi_clone = evo.multi_clone
+
+        local prefab = evo.spawn { [RF12345] = true }
+
+        multi_clone(N, prefab)
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Multi Defer Clone | %d entities with 5 required components', N),
+    function()
+        local multi_clone = evo.multi_clone
+
+        local prefab = evo.spawn { [RF12345] = true }
+
+        evo.defer()
+        multi_clone(N, prefab)
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Clone Benchmarks: Multi Clone With Defaults | %d entities with 5 required components', N),
+    function()
+        local multi_clone = evo.multi_clone
+
+        local prefab = evo.spawn { [RD12345] = true }
+
+        multi_clone(N, prefab)
+
+        evo.batch_destroy(QD1)
+    end)
--- a/develop/benchmarks/common_bmarks.lua
+++ b/develop/benchmarks/common_bmarks.lua
@@ -0,0 +1,340 @@
+local evo = require 'evolved'
+local basics = require 'develop.basics'
+
+local tiny = require 'develop.3rdparty.tiny'
+
+evo.debug_mode(false)
+
+local N = 1000
+
+print '----------------------------------------'
+
+basics.describe_bench(string.format('Common Benchmarks: Tiny Entity Cycle | %d entities', N),
+    function(world)
+        world:update()
+    end, function()
+        local world = tiny.world()
+
+        for _ = 1, N do
+            world:addEntity({ a = 0 })
+        end
+
+        local A = tiny.processingSystem()
+        A.filter = tiny.requireAll('a')
+        A.process = function(_, e) world:addEntity({ b = e.a }) end
+        A.postProcess = function(_) world:refresh() end
+
+        local B = tiny.processingSystem()
+        B.filter = tiny.requireAll('b')
+        B.process = function(_, e) world:removeEntity(e) end
+        B.postProcess = function(_) world:refresh() end
+
+        world:addSystem(A)
+        world:addSystem(B)
+
+        world:refresh()
+
+        return world
+    end)
+
+basics.describe_bench(string.format('Common Benchmarks: Evolved Entity Cycle | %d entities', N),
+    function(world)
+        evo.process(world)
+    end, function()
+        local world = evo.builder()
+            :destruction_policy(evo.DESTRUCTION_POLICY_DESTROY_ENTITY)
+            :spawn()
+
+        local a = evo.builder():set(world):spawn()
+        local b = evo.builder():set(world):spawn()
+
+        local query_a = evo.builder():set(world):include(a):spawn()
+        local query_b = evo.builder():set(world):include(b):spawn()
+
+        local prefab_a = evo.builder():prefab():set(world):set(a, 0):spawn()
+        local prefab_b = evo.builder():prefab():set(world):set(b, 0):spawn()
+
+        evo.multi_clone(N, prefab_a)
+
+        evo.builder()
+            :set(world):group(world):query(query_a)
+            :execute(function(chunk, _, entity_count)
+                local as = chunk:components(a)
+                local entity_bs = evo.multi_clone(entity_count, prefab_b)
+                for i = 1, entity_count do evo.set(entity_bs[i], b, as[i]) end
+            end):spawn()
+
+        evo.builder()
+            :set(world):group(world):query(query_b)
+            :prologue(function()
+                evo.batch_destroy(query_b)
+            end):spawn()
+
+        return world
+    end, function(world)
+        evo.destroy(world)
+    end)
+
+print '----------------------------------------'
+
+basics.describe_bench(string.format('Common Benchmarks: Tiny Simple Iteration | %d entities', N),
+    function(world)
+        world:update()
+    end, function()
+        local world = tiny.world()
+
+        for _ = 1, N do
+            world:addEntity({ a = 0, b = 0 })
+            world:addEntity({ a = 0, b = 0, c = 0 })
+            world:addEntity({ a = 0, b = 0, c = 0, d = 0 })
+            world:addEntity({ a = 0, b = 0, c = 0, e = 0 })
+        end
+
+        local AB = tiny.processingSystem()
+        AB.filter = tiny.requireAll('a', 'b')
+        AB.process = function(_, e) e.a, e.b = e.b, e.a end
+
+        local CD = tiny.processingSystem()
+        CD.filter = tiny.requireAll('c', 'd')
+        CD.process = function(_, e) e.c, e.d = e.d, e.c end
+
+        local CE = tiny.processingSystem()
+        CE.filter = tiny.requireAll('c', 'e')
+        CE.process = function(_, e) e.c, e.e = e.e, e.c end
+
+        world:addSystem(AB)
+        world:addSystem(CD)
+        world:addSystem(CE)
+
+        world:refresh()
+
+        return world
+    end)
+
+basics.describe_bench(string.format('Common Benchmarks: Evolved Simple Iteration | %d entities', N),
+    function(world)
+        evo.process(world)
+    end, function()
+        local world = evo.builder()
+            :destruction_policy(evo.DESTRUCTION_POLICY_DESTROY_ENTITY)
+            :spawn()
+
+        local a = evo.builder():set(world):spawn()
+        local b = evo.builder():set(world):spawn()
+        local c = evo.builder():set(world):spawn()
+        local d = evo.builder():set(world):spawn()
+        local e = evo.builder():set(world):spawn()
+
+        local query_ab = evo.builder():set(world):include(a, b):spawn()
+        local query_cd = evo.builder():set(world):include(c, d):spawn()
+        local query_ce = evo.builder():set(world):include(c, e):spawn()
+
+        evo.multi_spawn(N, { [world] = true, [a] = 0, [b] = 0 })
+        evo.multi_spawn(N, { [world] = true, [a] = 0, [b] = 0, [c] = 0 })
+        evo.multi_spawn(N, { [world] = true, [a] = 0, [b] = 0, [c] = 0, [d] = 0 })
+        evo.multi_spawn(N, { [world] = true, [a] = 0, [b] = 0, [c] = 0, [e] = 0 })
+
+        evo.builder()
+            :set(world):group(world):query(query_ab)
+            :execute(function(chunk, _, entity_count)
+                local as, bs = chunk:components(a, b)
+                for i = 1, entity_count do as[i], bs[i] = bs[i], as[i] end
+            end):spawn()
+
+        evo.builder()
+            :set(world):group(world):query(query_cd)
+            :execute(function(chunk, _, entity_count)
+                local cs, ds = chunk:components(c, d)
+                for i = 1, entity_count do cs[i], ds[i] = ds[i], cs[i] end
+            end):spawn()
+
+        evo.builder()
+            :set(world):group(world):query(query_ce)
+            :execute(function(chunk, _, entity_count)
+                local cs, es = chunk:components(c, e)
+                for i = 1, entity_count do cs[i], es[i] = es[i], cs[i] end
+            end):spawn()
+
+        return world
+    end, function(world)
+        evo.destroy(world)
+    end)
+
+print '----------------------------------------'
+
+basics.describe_bench(string.format('Common Benchmarks: Tiny Packed Iteration | %d entities', N),
+    function(world)
+        world:update()
+    end, function()
+        local world = tiny.world()
+
+        for _ = 1, N do
+            world:addEntity({ a = 0, b = 0, c = 0, d = 0, e = 0 })
+        end
+
+        local A = tiny.processingSystem()
+        A.filter = tiny.requireAll('a')
+        A.process = function(_, e) e.a = e.a * 2 end
+
+        local B = tiny.processingSystem()
+        B.filter = tiny.requireAll('b')
+        B.process = function(_, e) e.b = e.b * 2 end
+
+        local C = tiny.processingSystem()
+        C.filter = tiny.requireAll('c')
+        C.process = function(_, e) e.c = e.c * 2 end
+
+        local D = tiny.processingSystem()
+        D.filter = tiny.requireAll('d')
+        D.process = function(_, e) e.d = e.d * 2 end
+
+        local E = tiny.processingSystem()
+        E.filter = tiny.requireAll('e')
+        E.process = function(_, e) e.e = e.e * 2 end
+
+        world:addSystem(A)
+        world:addSystem(B)
+        world:addSystem(C)
+        world:addSystem(D)
+        world:addSystem(E)
+
+        world:refresh()
+
+        return world
+    end)
+
+basics.describe_bench(string.format('Common Benchmarks: Evolved Packed Iteration | %d entities', N),
+    function(world)
+        evo.process(world)
+    end, function()
+        local world = evo.builder()
+            :destruction_policy(evo.DESTRUCTION_POLICY_DESTROY_ENTITY)
+            :spawn()
+
+        local a = evo.builder():set(world):spawn()
+        local b = evo.builder():set(world):spawn()
+        local c = evo.builder():set(world):spawn()
+        local d = evo.builder():set(world):spawn()
+        local e = evo.builder():set(world):spawn()
+
+        local query_a = evo.builder():set(world):include(a):spawn()
+        local query_b = evo.builder():set(world):include(b):spawn()
+        local query_c = evo.builder():set(world):include(c):spawn()
+        local query_d = evo.builder():set(world):include(d):spawn()
+        local query_e = evo.builder():set(world):include(e):spawn()
+
+        evo.multi_spawn(N, { [world] = true, [a] = 0, [b] = 0, [c] = 0, [d] = 0, [e] = 0 })
+
+        evo.builder()
+            :set(world):group(world):query(query_a)
+            :execute(function(chunk, _, entity_count)
+                local as = chunk:components(a)
+                for i = 1, entity_count do as[i] = as[i] * 2 end
+            end):spawn()
+
+        evo.builder()
+            :set(world):group(world):query(query_b)
+            :execute(function(chunk, _, entity_count)
+                local bs = chunk:components(b)
+                for i = 1, entity_count do bs[i] = bs[i] * 2 end
+            end):spawn()
+
+        evo.builder()
+            :set(world):group(world):query(query_c)
+            :execute(function(chunk, _, entity_count)
+                local cs = chunk:components(c)
+                for i = 1, entity_count do cs[i] = cs[i] * 2 end
+            end):spawn()
+
+        evo.builder()
+            :set(world):group(world):query(query_d)
+            :execute(function(chunk, _, entity_count)
+                local ds = chunk:components(d)
+                for i = 1, entity_count do ds[i] = ds[i] * 2 end
+            end):spawn()
+
+        evo.builder()
+            :set(world):group(world):query(query_e)
+            :execute(function(chunk, _, entity_count)
+                local es = chunk:components(e)
+                for i = 1, entity_count do es[i] = es[i] * 2 end
+            end):spawn()
+
+        return world
+    end, function(world)
+        evo.destroy(world)
+    end)
+
+print '----------------------------------------'
+
+basics.describe_bench(string.format('Common Benchmarks: Tiny Fragmented Iteration | %d entities', N),
+    function(world)
+        world:update()
+    end, function()
+        local world = tiny.world()
+
+        ---@type string[]
+        local chars = {}
+
+        for i = 1, 26 do
+            chars[i] = string.char(string.byte('a') + i - 1)
+        end
+
+        for i, char in ipairs(chars) do
+            for _ = 1, N do
+                world:addEntity({ [char] = i, data = i })
+            end
+        end
+
+        local Data = tiny.processingSystem()
+        Data.filter = tiny.requireAll('data')
+        Data.process = function(_, e) e.data = e.data * 2 end
+
+        local Last = tiny.processingSystem()
+        Last.filter = tiny.requireAll('z')
+        Last.process = function(_, e) e.z = e.z * 2 end
+
+        world:addSystem(Data)
+        world:addSystem(Last)
+
+        world:refresh()
+
+        return world
+    end)
+
+basics.describe_bench(string.format('Common Benchmarks: Evolved Fragmented Iteration | %d entities', N),
+    function(world)
+        evo.process(world)
+    end, function()
+        local world = evo.builder()
+            :destruction_policy(evo.DESTRUCTION_POLICY_DESTROY_ENTITY)
+            :spawn()
+
+        local data = evo.spawn { [world] = true }
+        local chars = evo.multi_spawn(26, { [world] = true })
+
+        local query_data = evo.builder():set(world):include(data):spawn()
+        local query_z = evo.builder():set(world):include(chars[#chars]):spawn()
+
+        for i = 1, #chars do
+            evo.multi_spawn(N, { [world] = true, [chars[i]] = i, [data] = i })
+        end
+
+        evo.builder()
+            :set(world):group(world):query(query_data)
+            :execute(function(chunk, _, entity_count)
+                local datas = chunk:components(data)
+                for i = 1, entity_count do datas[i] = datas[i] * 2 end
+            end):spawn()
+
+        evo.builder()
+            :set(world):group(world):query(query_z)
+            :execute(function(chunk, _, entity_count)
+                local zs = chunk:components(chars[#chars])
+                for i = 1, entity_count do zs[i] = zs[i] * 2 end
+            end):spawn()
+
+        return world
+    end, function(world)
+        evo.destroy(world)
+    end)
--- a/develop/benchmarks/migration_bmarks.lua
+++ b/develop/benchmarks/migration_bmarks.lua
@@ -0,0 +1,104 @@
+local evo = require 'evolved'
+local basics = require 'develop.basics'
+
+evo.debug_mode(false)
+
+local N = 1000
+
+local F1, F2, F3, F4, F5 = evo.id(5)
+
+local Q1 = evo.builder():include(F1):spawn()
+
+print '----------------------------------------'
+
+basics.describe_bench(string.format('Migration Benchmarks: Defer Set | %d entities with 1 component', N),
+    function()
+        local id, set = evo.id, evo.set
+
+        evo.defer()
+        for _ = 1, N do
+            local e = id()
+            set(e, F1)
+        end
+        evo.commit()
+
+        evo.batch_destroy(Q1)
+    end)
+
+basics.describe_bench(string.format('Migration Benchmarks: Defer Set | %d entities with 3 components', N),
+    function()
+        local id, set = evo.id, evo.set
+
+        evo.defer()
+        for _ = 1, N do
+            local e = id()
+            set(e, F1)
+            set(e, F2)
+            set(e, F3)
+        end
+        evo.commit()
+
+        evo.batch_destroy(Q1)
+    end)
+
+basics.describe_bench(string.format('Migration Benchmarks: Defer Set | %d entities with 5 components', N),
+    function()
+        local id, set = evo.id, evo.set
+
+        evo.defer()
+        for _ = 1, N do
+            local e = id()
+            set(e, F1)
+            set(e, F2)
+            set(e, F3)
+            set(e, F4)
+            set(e, F5)
+        end
+        evo.commit()
+
+        evo.batch_destroy(Q1)
+    end)
+
+print '----------------------------------------'
+
+basics.describe_bench(string.format('Migration Benchmarks: Simple Set | %d entities with 1 component', N),
+    function()
+        local id, set = evo.id, evo.set
+
+        for _ = 1, N do
+            local e = id()
+            set(e, F1)
+        end
+
+        evo.batch_destroy(Q1)
+    end)
+
+basics.describe_bench(string.format('Migration Benchmarks: Simple Set | %d entities with 3 components', N),
+    function()
+        local id, set = evo.id, evo.set
+
+        for _ = 1, N do
+            local e = id()
+            set(e, F1)
+            set(e, F2)
+            set(e, F3)
+        end
+
+        evo.batch_destroy(Q1)
+    end)
+
+basics.describe_bench(string.format('Migration Benchmarks: Simple Set | %d entities with 5 components', N),
+    function()
+        local id, set = evo.id, evo.set
+
+        for _ = 1, N do
+            local e = id()
+            set(e, F1)
+            set(e, F2)
+            set(e, F3)
+            set(e, F4)
+            set(e, F5)
+        end
+
+        evo.batch_destroy(Q1)
+    end)
--- a/develop/benchmarks/process_bmarks.lua
+++ b/develop/benchmarks/process_bmarks.lua
@@ -0,0 +1,102 @@
+local evo = require 'evolved'
+local basics = require 'develop.basics'
+
+evo.debug_mode(false)
+
+local N = 10000
+
+print '----------------------------------------'
+
+basics.describe_bench(string.format('Process Benchmarks: Evolved AoS Processing | %d entities', N),
+    function(w)
+        evo.process(w)
+    end,
+
+    function()
+        local wf = evo.builder()
+            :set(evo.DESTRUCTION_POLICY, evo.DESTRUCTION_POLICY_DESTROY_ENTITY)
+            :spawn()
+
+        local pf = evo.builder():set(wf):spawn()
+        local vf = evo.builder():set(wf):spawn()
+
+        evo.multi_spawn(N, {
+            [wf] = true,
+            [pf] = { x = 0, y = 0, z = 0, w = 0 },
+            [vf] = { x = 0, y = 0, z = 0, w = 0 },
+        })
+
+        evo.builder()
+            :set(wf)
+            :set(evo.GROUP, wf)
+            :set(evo.QUERY, evo.builder():set(wf):include(pf, vf):spawn())
+            :set(evo.EXECUTE, function(chunk, _, entity_count)
+                local ps, vs = chunk:components(pf, vf)
+
+                for i = 1, entity_count do
+                    local p, s = ps[i], vs[i]
+                    p.x = p.x + s.x
+                    p.y = p.y + s.y
+                end
+            end)
+            :spawn()
+
+        return wf
+    end,
+
+    function(w)
+        evo.destroy(w)
+    end)
+
+basics.describe_bench(string.format('Process Benchmarks: Evolved SoA Processing | %d entities', N),
+    function(w)
+        evo.process(w)
+    end,
+
+    function()
+        local wf = evo.builder()
+            :set(evo.DESTRUCTION_POLICY, evo.DESTRUCTION_POLICY_DESTROY_ENTITY)
+            :spawn()
+
+        local pxf = evo.builder():set(wf):spawn()
+        local pyf = evo.builder():set(wf):spawn()
+        local pzf = evo.builder():set(wf):spawn()
+        local pwf = evo.builder():set(wf):spawn()
+        local vxf = evo.builder():set(wf):spawn()
+        local vyf = evo.builder():set(wf):spawn()
+        local vzf = evo.builder():set(wf):spawn()
+        local vwf = evo.builder():set(wf):spawn()
+
+        evo.multi_spawn(N, {
+            [wf] = true,
+            [pxf] = 0,
+            [pyf] = 0,
+            [pzf] = 0,
+            [pwf] = 0,
+            [vxf] = 0,
+            [vyf] = 0,
+            [vzf] = 0,
+            [vwf] = 0,
+        })
+
+        evo.builder()
+            :set(wf)
+            :set(evo.GROUP, wf)
+            :set(evo.QUERY, evo.builder():set(wf):include(pxf, pyf, vxf, vyf):spawn())
+            :set(evo.EXECUTE, function(chunk, _, entity_count)
+                local pxs, pys = chunk:components(pxf, pyf)
+                local vxs, vys = chunk:components(vxf, vyf)
+
+                for i = 1, entity_count do
+                    pxs[i] = pxs[i] + vxs[i]
+                    pys[i] = pys[i] + vys[i]
+                end
+            end)
+            :spawn()
+
+        return wf
+    end,
+
+    function(w)
+        evo.destroy(w)
+    end)
--- a/develop/benchmarks/spawn_bmarks.lua
+++ b/develop/benchmarks/spawn_bmarks.lua
@@ -0,0 +1,764 @@
+local evo = require 'evolved'
+local basics = require 'develop.basics'
+
+evo.debug_mode(false)
+
+local N = 1000
+
+local F1, F2, F3, F4, F5 = evo.id(5)
+local D1, D2, D3, D4, D5 = evo.id(5)
+
+evo.set(D1, evo.DEFAULT, true)
+evo.set(D2, evo.DEFAULT, true)
+evo.set(D3, evo.DEFAULT, true)
+evo.set(D4, evo.DEFAULT, true)
+evo.set(D5, evo.DEFAULT, true)
+
+evo.set(D1, evo.DUPLICATE, function(v) return not v end)
+evo.set(D2, evo.DUPLICATE, function(v) return not v end)
+evo.set(D3, evo.DUPLICATE, function(v) return not v end)
+evo.set(D4, evo.DUPLICATE, function(v) return not v end)
+evo.set(D5, evo.DUPLICATE, function(v) return not v end)
+
+local QF1 = evo.builder():include(F1):spawn()
+local QD1 = evo.builder():include(D1):spawn()
+
+local RF1 = evo.builder():require(F1):spawn()
+local RF123 = evo.builder():require(F1, F2, F3):spawn()
+local RF12345 = evo.builder():require(F1, F2, F3, F4, F5):spawn()
+
+local RD1 = evo.builder():require(D1):spawn()
+local RD123 = evo.builder():require(D1, D2, D3):spawn()
+local RD12345 = evo.builder():require(D1, D2, D3, D4, D5):spawn()
+
+print '----------------------------------------'
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Simple Spawn | %d entities with 1 component', N),
+    function()
+        local spawn = evo.spawn
+
+        local components = { [F1] = true }
+
+        for _ = 1, N do
+            spawn(components)
+        end
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Simple Defer Spawn | %d entities with 1 component', N),
+    function()
+        local spawn = evo.spawn
+
+        local components = { [F1] = true }
+
+        evo.defer()
+        for _ = 1, N do
+            spawn(components)
+        end
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Simple Spawn With Defaults | %d entities with 1 component', N),
+    function()
+        local spawn = evo.spawn
+
+        local components = { [D1] = true }
+
+        for _ = 1, N do
+            spawn(components)
+        end
+
+        evo.batch_destroy(QD1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Simple Spawn | %d entities with 3 components', N),
+    function()
+        local spawn = evo.spawn
+
+        local components = { [F1] = true, [F2] = true, [F3] = true }
+
+        for _ = 1, N do
+            spawn(components)
+        end
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Simple Defer Spawn | %d entities with 3 components', N),
+    function()
+        local spawn = evo.spawn
+
+        local components = { [F1] = true, [F2] = true, [F3] = true }
+
+        evo.defer()
+        for _ = 1, N do
+            spawn(components)
+        end
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Simple Spawn With Defaults | %d entities with 3 components', N),
+    function()
+        local spawn = evo.spawn
+
+        local components = { [D1] = true, [D2] = true, [D3] = true }
+
+        for _ = 1, N do
+            spawn(components)
+        end
+
+        evo.batch_destroy(QD1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Simple Spawn | %d entities with 5 components', N),
+    function()
+        local spawn = evo.spawn
+
+        local components = { [F1] = true, [F2] = true, [F3] = true, [F4] = true, [F5] = true }
+
+        for _ = 1, N do
+            spawn(components)
+        end
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Simple Defer Spawn | %d entities with 5 components', N),
+    function()
+        local spawn = evo.spawn
+
+        local components = { [F1] = true, [F2] = true, [F3] = true, [F4] = true, [F5] = true }
+
+        evo.defer()
+        for _ = 1, N do
+            spawn(components)
+        end
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Simple Spawn With Defaults | %d entities with 5 components', N),
+    function()
+        local spawn = evo.spawn
+
+        local components = { [D1] = true, [D2] = true, [D3] = true, [D4] = true, [D5] = true }
+
+        for _ = 1, N do
+            spawn(components)
+        end
+
+        evo.batch_destroy(QD1)
+    end)
+
+print '----------------------------------------'
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Simple Spawn | %d entities with 1 required component', N),
+    function()
+        local spawn = evo.spawn
+
+        local components = { [RF1] = true }
+
+        for _ = 1, N do
+            spawn(components)
+        end
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Simple Defer Spawn | %d entities with 1 required component', N),
+    function()
+        local spawn = evo.spawn
+
+        local components = { [RF1] = true }
+
+        evo.defer()
+        for _ = 1, N do
+            spawn(components)
+        end
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Simple Spawn With Defaults | %d entities with 1 required component', N),
+    function()
+        local spawn = evo.spawn
+
+        local components = { [RD1] = true }
+
+        for _ = 1, N do
+            spawn(components)
+        end
+
+        evo.batch_destroy(QD1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Simple Spawn | %d entities with 3 required components', N),
+    function()
+        local spawn = evo.spawn
+
+        local components = { [RF123] = true }
+
+        for _ = 1, N do
+            spawn(components)
+        end
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Simple Defer Spawn | %d entities with 3 required components', N),
+    function()
+        local spawn = evo.spawn
+
+        local components = { [RF123] = true }
+
+        evo.defer()
+        for _ = 1, N do
+            spawn(components)
+        end
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Simple Spawn With Defaults | %d entities with 3 required components', N),
+    function()
+        local spawn = evo.spawn
+
+        local components = { [RD123] = true }
+
+        for _ = 1, N do
+            spawn(components)
+        end
+
+        evo.batch_destroy(QD1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Simple Spawn | %d entities with 5 required components', N),
+    function()
+        local spawn = evo.spawn
+
+        local components = { [RF12345] = true }
+
+        for _ = 1, N do
+            spawn(components)
+        end
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Simple Defer Spawn | %d entities with 5 required components', N),
+    function()
+        local spawn = evo.spawn
+
+        local components = { [RF12345] = true }
+
+        evo.defer()
+        for _ = 1, N do
+            spawn(components)
+        end
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Simple Spawn With Defaults | %d entities with 5 required components', N),
+    function()
+        local spawn = evo.spawn
+
+        local components = { [RD12345] = true }
+
+        for _ = 1, N do
+            spawn(components)
+        end
+
+        evo.batch_destroy(QD1)
+    end)
+
+print '----------------------------------------'
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Builder Spawn | %d entities with 1 component', N),
+    function()
+        local builder = evo.builder():set(F1)
+
+        for _ = 1, N do
+            builder:spawn()
+        end
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Builder Defer Spawn | %d entities with 1 component', N),
+    function()
+        local builder = evo.builder():set(F1)
+
+        evo.defer()
+        for _ = 1, N do
+            builder:spawn()
+        end
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Builder Spawn With Defaults | %d entities with 1 component', N),
+    function()
+        local builder = evo.builder():set(D1)
+
+        for _ = 1, N do
+            builder:spawn()
+        end
+
+        evo.batch_destroy(QD1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Builder Spawn | %d entities with 3 components', N),
+    function()
+        local builder = evo.builder():set(F1):set(F2):set(F3)
+
+        for _ = 1, N do
+            builder:spawn()
+        end
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Builder Defer Spawn | %d entities with 3 components', N),
+    function()
+        local builder = evo.builder():set(F1):set(F2):set(F3)
+
+        evo.defer()
+        for _ = 1, N do
+            builder:spawn()
+        end
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Builder Spawn With Defaults | %d entities with 3 components', N),
+    function()
+        local builder = evo.builder():set(D1):set(D2):set(D3)
+
+        for _ = 1, N do
+            builder:spawn()
+        end
+
+        evo.batch_destroy(QD1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Builder Spawn | %d entities with 5 components', N),
+    function()
+        local builder = evo.builder():set(F1):set(F2):set(F3):set(F4):set(F5)
+
+        for _ = 1, N do
+            builder:spawn()
+        end
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Builder Defer Spawn | %d entities with 5 components', N),
+    function()
+        local builder = evo.builder():set(F1):set(F2):set(F3):set(F4):set(F5)
+
+        evo.defer()
+        for _ = 1, N do
+            builder:spawn()
+        end
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Builder Spawn With Defaults | %d entities with 5 components', N),
+    function()
+        local builder = evo.builder():set(D1):set(D2):set(D3):set(D4):set(D5)
+
+        for _ = 1, N do
+            builder:spawn()
+        end
+
+        evo.batch_destroy(QD1)
+    end)
+
+print '----------------------------------------'
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Builder Spawn | %d entities with 1 required component', N),
+    function()
+        local builder = evo.builder():set(RF1)
+
+        for _ = 1, N do
+            builder:spawn()
+        end
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Builder Defer Spawn | %d entities with 1 required component', N),
+    function()
+        local builder = evo.builder():set(RF1)
+
+        evo.defer()
+        for _ = 1, N do
+            builder:spawn()
+        end
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Builder Spawn With Defaults | %d entities with 1 required component', N),
+    function()
+        local builder = evo.builder():set(RD1)
+
+        for _ = 1, N do
+            builder:spawn()
+        end
+
+        evo.batch_destroy(QD1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Builder Spawn | %d entities with 3 required components', N),
+    function()
+        local builder = evo.builder():set(RF123)
+
+        for _ = 1, N do
+            builder:spawn()
+        end
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Builder Defer Spawn | %d entities with 3 required components', N),
+    function()
+        local builder = evo.builder():set(RF123)
+
+        evo.defer()
+        for _ = 1, N do
+            builder:spawn()
+        end
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Builder Spawn With Defaults | %d entities with 3 required components', N),
+    function()
+        local builder = evo.builder():set(RD123)
+
+        for _ = 1, N do
+            builder:spawn()
+        end
+
+        evo.batch_destroy(QD1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Builder Spawn | %d entities with 5 required components', N),
+    function()
+        local builder = evo.builder():set(RF12345)
+
+        for _ = 1, N do
+            builder:spawn()
+        end
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Builder Defer Spawn | %d entities with 5 required components', N),
+    function()
+        local builder = evo.builder():set(RF12345)
+
+        evo.defer()
+        for _ = 1, N do
+            builder:spawn()
+        end
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Builder Spawn With Defaults | %d entities with 5 required components', N),
+    function()
+        local builder = evo.builder():set(RD12345)
+
+        for _ = 1, N do
+            builder:spawn()
+        end
+
+        evo.batch_destroy(QD1)
+    end)
+
+print '----------------------------------------'
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Multi Spawn | %d entities with 1 component', N),
+    function()
+        local multi_spawn = evo.multi_spawn
+
+        local components = { [F1] = true }
+
+        multi_spawn(N, components)
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Multi Defer Spawn | %d entities with 1 component', N),
+    function()
+        local multi_spawn = evo.multi_spawn
+
+        local components = { [F1] = true }
+
+        evo.defer()
+        multi_spawn(N, components)
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Multi Spawn With Defaults | %d entities with 1 component', N),
+    function()
+        local multi_spawn = evo.multi_spawn
+
+        local components = { [D1] = true }
+
+        multi_spawn(N, components)
+
+        evo.batch_destroy(QD1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Multi Spawn | %d entities with 3 components', N),
+    function()
+        local multi_spawn = evo.multi_spawn
+
+        local components = { [F1] = true, [F2] = true, [F3] = true }
+
+        multi_spawn(N, components)
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Multi Defer Spawn | %d entities with 3 components', N),
+    function()
+        local multi_spawn = evo.multi_spawn
+
+        local components = { [F1] = true, [F2] = true, [F3] = true }
+
+        evo.defer()
+        multi_spawn(N, components)
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Multi Spawn With Defaults | %d entities with 3 components', N),
+    function()
+        local multi_spawn = evo.multi_spawn
+
+        local components = { [D1] = true, [D2] = true, [D3] = true }
+
+        multi_spawn(N, components)
+
+        evo.batch_destroy(QD1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Multi Spawn | %d entities with 5 components', N),
+    function()
+        local multi_spawn = evo.multi_spawn
+
+        local components = { [F1] = true, [F2] = true, [F3] = true, [F4] = true, [F5] = true }
+
+        multi_spawn(N, components)
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Multi Defer Spawn | %d entities with 5 components', N),
+    function()
+        local multi_spawn = evo.multi_spawn
+
+        local components = { [F1] = true, [F2] = true, [F3] = true, [F4] = true, [F5] = true }
+
+        evo.defer()
+        multi_spawn(N, components)
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Multi Spawn With Defaults | %d entities with 5 components', N),
+    function()
+        local multi_spawn = evo.multi_spawn
+
+        local components = { [D1] = true, [D2] = true, [D3] = true, [D4] = true, [D5] = true }
+
+        multi_spawn(N, components)
+
+        evo.batch_destroy(QD1)
+    end)
+
+print '----------------------------------------'
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Multi Spawn | %d entities with 1 required component', N),
+    function()
+        local multi_spawn = evo.multi_spawn
+
+        local components = { [F1] = true }
+
+        multi_spawn(N, components)
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Multi Defer Spawn | %d entities with 1 required component', N),
+    function()
+        local multi_spawn = evo.multi_spawn
+
+        local components = { [F1] = true }
+
+        evo.defer()
+        multi_spawn(N, components)
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Multi Spawn With Defaults | %d entities with 1 required component', N),
+    function()
+        local multi_spawn = evo.multi_spawn
+
+        local components = { [D1] = true }
+
+        multi_spawn(N, components)
+
+        evo.batch_destroy(QD1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Multi Spawn | %d entities with 3 required components', N),
+    function()
+        local multi_spawn = evo.multi_spawn
+
+        local components = { [RF123] = true }
+
+        multi_spawn(N, components)
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Multi Defer Spawn | %d entities with 3 required components', N),
+    function()
+        local multi_spawn = evo.multi_spawn
+
+        local components = { [RF123] = true }
+
+        evo.defer()
+        multi_spawn(N, components)
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Multi Spawn With Defaults | %d entities with 3 required components', N),
+    function()
+        local multi_spawn = evo.multi_spawn
+
+        local components = { [RD123] = true }
+
+        multi_spawn(N, components)
+
+        evo.batch_destroy(QD1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Multi Spawn | %d entities with 5 required components', N),
+    function()
+        local multi_spawn = evo.multi_spawn
+
+        local components = { [RF12345] = true }
+
+        multi_spawn(N, components)
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Multi Defer Spawn | %d entities with 5 required components', N),
+    function()
+        local multi_spawn = evo.multi_spawn
+
+        local components = { [RF12345] = true }
+
+        evo.defer()
+        multi_spawn(N, components)
+        evo.commit()
+
+        evo.batch_destroy(QF1)
+    end)
+
+basics.describe_bench(
+    string.format('Spawn Benchmarks: Multi Spawn With Defaults | %d entities with 5 required components', N),
+    function()
+        local multi_spawn = evo.multi_spawn
+
+        local components = { [RD12345] = true }
+
+        multi_spawn(N, components)
+
+        evo.batch_destroy(QD1)
+    end)
--- a/develop/benchmarks/table_bmarks.lua
+++ b/develop/benchmarks/table_bmarks.lua
@@ -0,0 +1,136 @@
+local evo = require 'evolved'
+local basics = require 'develop.basics'
+
+evo.debug_mode(false)
+
+local N = 1000
+
+local F1, F2, F3, F4, F5 = evo.id(5)
+
+print '----------------------------------------'
+
+basics.describe_bench(string.format('Table Benchmarks: Allocate %d tables', N),
+    function(tables)
+        for i = 1, N do
+            local t = {}
+            tables[i] = t
+        end
+    end, function()
+        return {}
+    end)
+
+basics.describe_bench(string.format('Table Benchmarks: Allocate and Collect %d tables', N),
+    function(tables)
+        for i = 1, N do
+            local t = {}
+            tables[i] = t
+        end
+
+        for i = 1, N do
+            tables[i] = nil
+        end
+
+        collectgarbage('collect')
+    end, function()
+        return {}
+    end)
+
+print '----------------------------------------'
+
+basics.describe_bench(string.format('Table Benchmarks: Allocate %d tables with 1 component / AoS', N),
+    function(tables)
+        for i = 1, N do
+            local e = {}
+            e[F1] = true
+            tables[i] = e
+        end
+    end, function()
+        return {}
+    end)
+
+basics.describe_bench(string.format('Table Benchmarks: Allocate %d tables with 3 components / AoS', N),
+    function(tables)
+        for i = 1, N do
+            local e = {}
+            e[F1] = true
+            e[F2] = true
+            e[F3] = true
+            tables[i] = e
+        end
+    end, function()
+        return {}
+    end)
+
+basics.describe_bench(string.format('Table Benchmarks: Allocate %d tables with 5 components / AoS', N),
+    function(tables)
+        for i = 1, N do
+            local e = {}
+            e[F1] = true
+            e[F2] = true
+            e[F3] = true
+            e[F4] = true
+            e[F5] = true
+            tables[i] = e
+        end
+    end, function()
+        return {}
+    end)
+
+print '----------------------------------------'
+
+basics.describe_bench(string.format('Table Benchmarks: Allocate %d tables with 1 component / SoA', N),
+    function(tables)
+        local fs1 = {}
+        for i = 1, N do
+            local e = {}
+            fs1[i] = true
+            tables[i] = e
+        end
+        tables[F1] = fs1
+    end, function()
+        return {}
+    end)
+
+basics.describe_bench(string.format('Table Benchmarks: Allocate %d tables with 3 components / SoA', N),
+    function(tables)
+        local fs1 = {}
+        local fs2 = {}
+        local fs3 = {}
+        for i = 1, N do
+            local e = {}
+            fs1[i] = true
+            fs2[i] = true
+            fs3[i] = true
+            tables[i] = e
+        end
+        tables[F1] = fs1
+        tables[F2] = fs2
+        tables[F3] = fs3
+    end, function()
+        return {}
+    end)
+
+basics.describe_bench(string.format('Table Benchmarks: Allocate %d tables with 5 components / SoA', N),
+    function(tables)
+        local fs1 = {}
+        local fs2 = {}
+        local fs3 = {}
+        local fs4 = {}
+        local fs5 = {}
+        for i = 1, N do
+            local e = {}
+            fs1[i] = true
+            fs2[i] = true
+            fs3[i] = true
+            fs4[i] = true
+            fs5[i] = true
+            tables[i] = e
+        end
+        tables[F1] = fs1
+        tables[F2] = fs2
+        tables[F3] = fs3
+        tables[F4] = fs4
+        tables[F5] = fs5
+    end, function()
+        return {}
+    end)
--- a/develop/fuzzing/execute_fuzz.lua
+++ b/develop/fuzzing/execute_fuzz.lua
@@ -0,0 +1,267 @@
+local evo = require 'evolved'
+
+evo.debug_mode(true)
+
+---
+---
+---
+---
+---
+
+local __table_unpack = (function()
+    ---@diagnostic disable-next-line: deprecated
+    return table.unpack or unpack
+end)()
+
+---
+---
+---
+---
+---
+
+local all_fragment_list = {} ---@type evolved.fragment[]
+
+for i = 1, math.random(1, 10) do
+    local fragment = evo.id()
+    all_fragment_list[i] = fragment
+end
+
+---@param query evolved.query
+local function generate_query(query)
+    local include_set = {}
+    local include_list = {}
+    local include_count = 0
+
+    for _ = 1, math.random(0, #all_fragment_list) do
+        local include = all_fragment_list[math.random(1, #all_fragment_list)]
+
+        if not include_set[include] then
+            include_count = include_count + 1
+            include_set[include] = include_count
+            include_list[include_count] = include
+        end
+    end
+
+    local exclude_set = {}
+    local exclude_list = {}
+    local exclude_count = 0
+
+    for _ = 1, math.random(0, #all_fragment_list) do
+        local exclude = all_fragment_list[math.random(1, #all_fragment_list)]
+
+        if not exclude_set[exclude] then
+            exclude_count = exclude_count + 1
+            exclude_set[exclude] = exclude_count
+            exclude_list[exclude_count] = exclude
+        end
+    end
+
+    if include_count > 0 then
+        evo.set(query, evo.INCLUDES, include_list)
+    end
+
+    if exclude_count > 0 then
+        evo.set(query, evo.EXCLUDES, exclude_list)
+    end
+end
+
+---@param query_count integer
+---@return evolved.query[] query_list
+---@return integer query_count
+---@nodiscard
+local function generate_queries(query_count)
+    local query_list = {} ---@type evolved.query[]
+
+    for i = 1, query_count do
+        local query = evo.id()
+        query_list[i] = query
+        generate_query(query)
+    end
+
+    return query_list, query_count
+end
+
+---@param entity evolved.entity
+local function generate_entity(entity)
+    for _ = 0, math.random(0, #all_fragment_list) do
+        local fragment = all_fragment_list[math.random(1, #all_fragment_list)]
+        evo.set(entity, fragment)
+    end
+end
+
+---@param entity_count integer
+---@return evolved.entity[] entity_list
+---@return integer entity_count
+local function generate_entities(entity_count)
+    local entity_list = {} ---@type evolved.entity[]
+
+    for i = 1, entity_count do
+        local entity = evo.id()
+        entity_list[i] = entity
+        generate_entity(entity)
+    end
+
+    return entity_list, entity_count
+end
+
+local pre_query_list, pre_query_count = generate_queries(math.random(1, 10))
+local pre_entity_list, pre_entity_count = generate_entities(math.random(1, 10))
+
+for _ = 1, math.random(1, 5) do
+    local fragment = all_fragment_list[math.random(1, #all_fragment_list)]
+
+    evo.set(fragment, evo.EXPLICIT)
+end
+
+for _ = 1, math.random(1, 5) do
+    local query = pre_query_list[math.random(1, pre_query_count)]
+
+    if math.random(1, 2) == 1 then
+        generate_query(query)
+    else
+        if math.random(1, 2) == 1 then
+            evo.remove(query, evo.INCLUDES)
+        else
+            evo.remove(query, evo.EXCLUDES)
+        end
+    end
+end
+
+local post_query_list, post_query_count = generate_queries(math.random(1, 10))
+local post_entity_list, post_entity_count = generate_entities(math.random(1, 10))
+
+---
+---
+---
+---
+---
+
+local all_query_list = {}
+local all_query_count = 0
+local all_entity_list = {}
+local all_entity_count = 0
+
+for i = 1, pre_query_count do
+    all_query_count = all_query_count + 1
+    all_query_list[all_query_count] = pre_query_list[i]
+end
+
+for i = 1, post_query_count do
+    all_query_count = all_query_count + 1
+    all_query_list[all_query_count] = post_query_list[i]
+end
+
+for i = 1, pre_entity_count do
+    all_entity_count = all_entity_count + 1
+    all_entity_list[all_entity_count] = pre_entity_list[i]
+end
+
+for i = 1, post_entity_count do
+    all_entity_count = all_entity_count + 1
+    all_entity_list[all_entity_count] = post_entity_list[i]
+end
+
+---
+---
+---
+---
+---
+
+local function execute_query(query)
+    local query_chunk_set = {}
+    local query_entity_set = {}
+
+    local query_include_list = evo.get(query, evo.INCLUDES) or {}
+    local query_exclude_list = evo.get(query, evo.EXCLUDES) or {}
+
+    local query_include_set = {}
+    for _, include in ipairs(query_include_list) do
+        query_include_set[include] = true
+    end
+
+    for chunk, entity_list, entity_count in evo.execute(query) do
+        assert(not query_chunk_set[chunk])
+        query_chunk_set[chunk] = true
+
+        for i = 1, entity_count do
+            local entity = entity_list[i]
+            assert(not query_entity_set[entity])
+            query_entity_set[entity] = true
+        end
+
+        assert(chunk:has_all(__table_unpack(query_include_list)))
+        assert(not chunk:has_any(__table_unpack(query_exclude_list)))
+    end
+
+    for i = 1, all_entity_count do
+        local entity = all_entity_list[i]
+
+        local is_entity_matched =
+            evo.has_all(entity, __table_unpack(query_include_list))
+            and not evo.has_any(entity, __table_unpack(query_exclude_list))
+
+        for fragment in evo.each(entity) do
+            if evo.has(fragment, evo.EXPLICIT) and not query_include_set[fragment] then
+                is_entity_matched = false
+            end
+        end
+
+        if is_entity_matched then
+            assert(query_entity_set[entity])
+        else
+            assert(not query_entity_set[entity])
+        end
+    end
+end
+
+for i = 1, all_query_count do
+    execute_query(all_query_list[i])
+end
+
+---
+---
+---
+---
+---
+
+for _ = 1, math.random(1, 5) do
+    local fragment = all_fragment_list[math.random(1, #all_fragment_list)]
+
+    evo.set(fragment, evo.EXPLICIT)
+end
+
+for _ = 1, math.random(1, 5) do
+    local query = pre_query_list[math.random(1, pre_query_count)]
+
+    if math.random(1, 2) == 1 then
+        generate_query(query)
+    else
+        if math.random(1, 2) == 1 then
+            evo.remove(query, evo.INCLUDES)
+        else
+            evo.remove(query, evo.EXCLUDES)
+        end
+    end
+end
+
+for i = 1, all_query_count do
+    execute_query(all_query_list[i])
+end
+
+---
+---
+---
+---
+---
+
+if math.random(1, 2) == 1 then
+    evo.collect_garbage()
+end
+
+evo.destroy(__table_unpack(all_query_list))
+evo.destroy(__table_unpack(all_entity_list))
+evo.destroy(__table_unpack(all_fragment_list))
+
+if math.random(1, 2) == 1 then
+    evo.collect_garbage()
+end
--- a/develop/testing/build_tests.lua
+++ b/develop/testing/build_tests.lua
@@ -0,0 +1,41 @@
+local evo = require 'evolved'
+
+do
+    local f1, f2 = evo.id(2)
+
+    do
+        local e = evo.builder():set(f1, 42):set(f2, 'hello'):build()
+        assert(evo.has(e, f1) and evo.get(e, f1) == 42)
+        assert(evo.has(e, f2) and evo.get(e, f2) == 'hello')
+    end
+
+    do
+        local p = evo.builder():set(f1, 42):build()
+        local e = evo.builder():set(f2, 'hello'):build(p)
+        assert(evo.has(e, f1) and evo.get(e, f1) == 42)
+        assert(evo.has(e, f2) and evo.get(e, f2) == 'hello')
+    end
+
+    do
+        local entity_list, entity_count = evo.builder():set(f1, 42):set(f2, 'hello'):multi_build(5)
+        assert(entity_count == 5)
+
+        for i = 1, entity_count do
+            local e = entity_list[i]
+            assert(evo.has(e, f1) and evo.get(e, f1) == 42)
+            assert(evo.has(e, f2) and evo.get(e, f2) == 'hello')
+        end
+    end
+
+    do
+        local p = evo.builder():set(f1, 42):build()
+        local entity_list, entity_count = evo.builder():set(f2, 'hello'):multi_build(5, p)
+        assert(entity_count == 5)
+
+        for i = 1, entity_count do
+            local e = entity_list[i]
+            assert(evo.has(e, f1) and evo.get(e, f1) == 42)
+            assert(evo.has(e, f2) and evo.get(e, f2) == 'hello')
+        end
+    end
+end
--- a/develop/testing/cancel_tests.lua
+++ b/develop/testing/cancel_tests.lua
@@ -0,0 +1,105 @@
+local evo = require 'evolved'
+
+do
+    assert(evo.defer())
+    assert(evo.cancel())
+end
+
+do
+    assert(evo.defer())
+    assert(not evo.defer())
+    assert(not evo.cancel())
+    assert(evo.commit())
+end
+
+do
+    assert(evo.defer())
+    assert(not evo.defer())
+    assert(not evo.cancel())
+    assert(evo.cancel())
+end
+
+do
+    assert(evo.defer())
+    assert(not evo.defer())
+    assert(not evo.cancel())
+    assert(not evo.defer())
+    assert(not evo.cancel())
+    assert(evo.commit())
+end
+
+do
+    local e, f = evo.id(2)
+
+    assert(evo.defer())
+    do
+        evo.set(e, f)
+        assert(not evo.has(e, f))
+    end
+    assert(evo.cancel())
+
+    assert(not evo.has(e, f))
+end
+
+do
+    local e, f1, f2 = evo.id(3)
+
+    assert(evo.defer())
+    do
+        evo.set(e, f1)
+        assert(not evo.has(e, f1))
+
+        assert(not evo.defer())
+        do
+            evo.set(e, f2)
+            assert(not evo.has(e, f2))
+        end
+        assert(not evo.cancel())
+    end
+    assert(evo.commit())
+
+    assert(evo.has(e, f1))
+    assert(not evo.has(e, f2))
+end
+
+do
+    local e, f1, f2 = evo.id(3)
+
+    assert(evo.defer())
+    do
+        evo.set(e, f1)
+        assert(not evo.has(e, f1))
+
+        assert(not evo.defer())
+        do
+            evo.set(e, f2)
+            assert(not evo.has(e, f2))
+        end
+        assert(not evo.cancel())
+    end
+    assert(evo.cancel())
+
+    assert(not evo.has(e, f1))
+    assert(not evo.has(e, f2))
+end
+
+do
+    local e, f1, f2 = evo.id(3)
+
+    assert(evo.defer())
+    do
+        evo.set(e, f1)
+        assert(not evo.has(e, f1))
+
+        assert(not evo.defer())
+        do
+            evo.set(e, f2)
+            assert(not evo.has(e, f2))
+        end
+        assert(not evo.commit())
+    end
+    assert(evo.cancel())
+
+    assert(not evo.has(e, f1))
+    assert(not evo.has(e, f2))
+end
--- a/develop/testing/clone_tests.lua
+++ b/develop/testing/clone_tests.lua
@@ -0,0 +1,397 @@
+local evo = require 'evolved'
+
+do
+    do
+        local p = evo.spawn()
+        local e = evo.clone(p)
+        assert(evo.alive(e) and evo.empty(e))
+    end
+
+    do
+        local p = evo.spawn()
+        local e = evo.clone(p, {})
+        assert(evo.alive(e) and evo.empty(e))
+    end
+
+    do
+        local f1, f2 = evo.id(2)
+        evo.set(f1, evo.REQUIRES, { f2 })
+        evo.set(f2, evo.DEFAULT, 42)
+
+        local p = evo.spawn()
+        local e = evo.clone(p, { [f1] = 'hello' })
+        assert(evo.alive(e) and not evo.empty(e) and evo.locate(e) == evo.chunk(f1, f2))
+        assert(evo.has(e, f1) and evo.get(e, f1) == 'hello')
+        assert(evo.has(e, f2) and evo.get(e, f2) == 42)
+    end
+end
+
+do
+    local f1, f2, f3, f4 = evo.id(4)
+    evo.set(f1, evo.TAG)
+    evo.set(f1, evo.REQUIRES, { f2, f3 })
+    evo.set(f4, evo.UNIQUE)
+
+    do
+        local p = evo.spawn { [f4] = 'unique' }
+        local e = evo.clone(p)
+        assert(evo.alive(e) and evo.empty(e))
+    end
+
+    do
+        local p = evo.spawn { [f4] = 'unique' }
+        local e = evo.clone(p, {})
+        assert(evo.alive(e) and evo.empty(e))
+    end
+
+    do
+        local p = evo.spawn { [f4] = 'unique' }
+        local e = evo.clone(p, { [f4] = 'another' })
+        assert(evo.alive(e) and not evo.empty(e) and evo.locate(e) == evo.chunk(f4))
+        assert(evo.has(e, f4) and evo.get(e, f4) == 'another')
+    end
+
+    do
+        local p = evo.spawn { [f2] = 100, [f4] = 'unique' }
+        local e = evo.clone(p, { [f4] = 'another' })
+        assert(evo.alive(e) and not evo.empty(e) and evo.locate(e) == evo.chunk(f2, f4))
+        assert(evo.has(e, f2) and evo.get(e, f2) == 100)
+        assert(evo.has(e, f4) and evo.get(e, f4) == 'another')
+    end
+
+    do
+        local p = evo.spawn { [f2] = 100, [f4] = 'unique' }
+        local e = evo.clone(p, { [f1] = 'hello', [f3] = 10 })
+        assert(evo.alive(e) and not evo.empty(e) and evo.locate(e) == evo.chunk(f1, f2, f3))
+        assert(evo.has(e, f1) and evo.get(e, f1) == nil)
+        assert(evo.has(e, f2) and evo.get(e, f2) == 100)
+        assert(evo.has(e, f3) and evo.get(e, f3) == 10)
+    end
+end
+
+do
+    do
+        local f1, f2, f3, f4 = evo.id(4)
+        evo.set(f4, evo.TAG)
+
+        do
+            local p = evo.spawn { [f2] = 21, [f3] = 'hello', [f4] = true }
+            local e = evo.clone(p, { [f1] = 'world', [f2] = 10 })
+            assert(evo.alive(e) and not evo.empty(e) and evo.locate(e) == evo.chunk(f1, f2, f3, f4))
+            assert(evo.has(e, f1) and evo.get(e, f1) == 'world')
+            assert(evo.has(e, f2) and evo.get(e, f2) == 10)
+            assert(evo.has(e, f3) and evo.get(e, f3) == 'hello')
+            assert(evo.has(e, f4) and evo.get(e, f4) == nil)
+        end
+    end
+
+    do
+        local f1, f2, f3, f4 = evo.id(4)
+        evo.set(f2, evo.DEFAULT, 42)
+        evo.set(f3, evo.DUPLICATE, function() return nil end)
+        evo.set(f4, evo.TAG)
+
+        do
+            local p = evo.spawn { [f2] = 21, [f3] = 'hello', [f4] = true }
+            local e = evo.clone(p, { [f1] = 'world', [f2] = 10 })
+            assert(evo.alive(e) and not evo.empty(e) and evo.locate(e) == evo.chunk(f1, f2, f3, f4))
+            assert(evo.has(e, f1) and evo.get(e, f1) == 'world')
+            assert(evo.has(e, f2) and evo.get(e, f2) == 10)
+            assert(evo.has(e, f3) and evo.get(e, f3) == true)
+            assert(evo.has(e, f4) and evo.get(e, f4) == nil)
+        end
+    end
+end
+
+do
+    local f1, f2, f3, f4 = evo.id(4)
+    evo.set(f1, evo.TAG)
+    evo.set(f1, evo.REQUIRES, { f2, f3 })
+    evo.set(f2, evo.DEFAULT, 42)
+    evo.set(f2, evo.DUPLICATE, function(v) return v * 2 end)
+    evo.set(f3, evo.DUPLICATE, function() return nil end)
+    evo.set(f4, evo.UNIQUE)
+
+    do
+        local p = evo.spawn { [f4] = 'unique' }
+        local e = evo.clone(p)
+        assert(evo.alive(e) and evo.empty(e))
+    end
+
+    do
+        local p = evo.spawn { [f4] = 'unique' }
+        local e = evo.clone(p, {})
+        assert(evo.alive(e) and evo.empty(e))
+    end
+
+    do
+        local p = evo.spawn { [f4] = 'unique' }
+        local e = evo.clone(p, { [f4] = 'another' })
+        assert(evo.alive(e) and not evo.empty(e) and evo.locate(e) == evo.chunk(f4))
+        assert(evo.has(e, f4) and evo.get(e, f4) == 'another')
+    end
+
+    do
+        local p = evo.spawn { [f2] = 100, [f4] = 'unique' }
+        local e = evo.clone(p, { [f4] = 'another' })
+        assert(evo.alive(e) and not evo.empty(e) and evo.locate(e) == evo.chunk(f2, f4))
+        assert(evo.has(e, f2) and evo.get(e, f2) == 200 * 2)
+        assert(evo.has(e, f4) and evo.get(e, f4) == 'another')
+    end
+
+    do
+        local p = evo.spawn { [f2] = 100, [f4] = 'unique' }
+        local e = evo.clone(p, { [f1] = 'hello', [f2] = 10 })
+        assert(evo.alive(e) and not evo.empty(e) and evo.locate(e) == evo.chunk(f1, f2, f3))
+        assert(evo.has(e, f1) and evo.get(e, f1) == nil)
+        assert(evo.has(e, f2) and evo.get(e, f2) == 10 * 2)
+        assert(evo.has(e, f3) and evo.get(e, f3) == true)
+    end
+
+    local f1_set_count, f1_inserted_count = 0, 0
+    local f2_set_sum, f3_inserted_count = 0, 0
+
+    evo.set(f1, evo.ON_SET, function(e, f, c)
+        assert(evo.get(e, f) == c)
+        f1_set_count = f1_set_count + 1
+    end)
+
+    evo.set(f1, evo.ON_INSERT, function(e, f, c)
+        assert(evo.get(e, f) == c)
+        f1_inserted_count = f1_inserted_count + 1
+    end)
+
+    evo.set(f2, evo.ON_SET, function(e, f, c)
+        assert(evo.get(e, f) == c)
+        f2_set_sum = f2_set_sum + c
+    end)
+
+    evo.set(f3, evo.ON_INSERT, function(e, f, c)
+        assert(evo.get(e, f) == c)
+        f3_inserted_count = f3_inserted_count + 1
+    end)
+
+    do
+        f1_set_count, f1_inserted_count = 0, 0
+        f2_set_sum, f3_inserted_count = 0, 0
+
+        local p = evo.spawn { [f2] = 100, [f4] = 'unique' }
+        local e = evo.clone(p, { [f1] = 'hello', [f2] = 10 })
+        assert(evo.alive(e) and not evo.empty(e) and evo.locate(e) == evo.chunk(f1, f2, f3))
+        assert(evo.has(e, f1) and evo.get(e, f1) == nil)
+        assert(evo.has(e, f2) and evo.get(e, f2) == 10 * 2)
+        assert(evo.has(e, f3) and evo.get(e, f3) == true)
+
+        assert(f1_set_count == 1)
+        assert(f1_inserted_count == 1)
+        assert(f2_set_sum == 100 * 2 + 10 * 2)
+        assert(f3_inserted_count == 1)
+    end
+end
+
+do
+    local f1, f2, f3, f4 = evo.id(4)
+    evo.set(f1, evo.TAG)
+    evo.set(f1, evo.REQUIRES, { f2, f3 })
+    evo.set(f4, evo.UNIQUE)
+
+    do
+        local p = evo.spawn { [f4] = 'unique' }
+        local es, ec = evo.multi_clone(1, p)
+        assert(#es == 1 and ec == 1)
+        for i = 1, ec do
+            assert(evo.alive(es[i]) and evo.empty(es[i]))
+        end
+    end
+
+    do
+        local p = evo.spawn { [f4] = 'unique' }
+        local es, ec = evo.multi_clone(2, p, {})
+        assert(#es == 2 and ec == 2)
+        for i = 1, ec do
+            assert(evo.alive(es[i]) and evo.empty(es[i]))
+        end
+    end
+
+    do
+        local p = evo.spawn { [f4] = 'unique' }
+        local es, ec = evo.multi_clone(3, p, { [f4] = 'another' })
+        assert(#es == 3 and ec == 3)
+        for i = 1, ec do
+            assert(evo.alive(es[i]) and not evo.empty(es[i]) and evo.locate(es[i]) == evo.chunk(f4))
+            assert(evo.has(es[i], f4) and evo.get(es[i], f4) == 'another')
+        end
+    end
+
+    do
+        local p = evo.spawn { [f2] = 100, [f4] = 'unique' }
+        local es, ec = evo.multi_clone(4, p, { [f4] = 'another' })
+        assert(#es == 4 and ec == 4)
+        for i = 1, ec do
+            assert(evo.alive(es[i]) and not evo.empty(es[i]) and evo.locate(es[i]) == evo.chunk(f2, f4))
+            assert(evo.has(es[i], f2) and evo.get(es[i], f2) == 100)
+            assert(evo.has(es[i], f4) and evo.get(es[i], f4) == 'another')
+        end
+    end
+
+    do
+        local p = evo.spawn { [f2] = 100, [f4] = 'unique' }
+        local es, ec = evo.multi_clone(5, p, { [f1] = 'hello', [f3] = 10 })
+        assert(#es == 5 and ec == 5)
+        for i = 1, ec do
+            assert(evo.alive(es[i]) and not evo.empty(es[i]) and evo.locate(es[i]) == evo.chunk(f1, f2, f3))
+            assert(evo.has(es[i], f1) and evo.get(es[i], f1) == nil)
+            assert(evo.has(es[i], f2) and evo.get(es[i], f2) == 100)
+            assert(evo.has(es[i], f3) and evo.get(es[i], f3) == 10)
+        end
+    end
+end
+
+do
+    do
+        local f1, f2, f3, f4 = evo.id(4)
+        evo.set(f4, evo.TAG)
+
+        do
+            local p = evo.spawn { [f2] = 21, [f3] = 'hello', [f4] = true }
+            local es, ec = evo.multi_clone(2, p, { [f1] = 'world', [f2] = 10 })
+            assert(#es == 2 and ec == 2)
+            for i = 1, ec do
+                assert(evo.alive(es[i]) and not evo.empty(es[i]) and evo.locate(es[i]) == evo.chunk(f1, f2, f3, f4))
+                assert(evo.has(es[i], f1) and evo.get(es[i], f1) == 'world')
+                assert(evo.has(es[i], f2) and evo.get(es[i], f2) == 10)
+                assert(evo.has(es[i], f3) and evo.get(es[i], f3) == 'hello')
+                assert(evo.has(es[i], f4) and evo.get(es[i], f4) == nil)
+            end
+        end
+    end
+
+    do
+        local f1, f2, f3, f4 = evo.id(4)
+        evo.set(f2, evo.DEFAULT, 42)
+        evo.set(f3, evo.DUPLICATE, function() return nil end)
+        evo.set(f4, evo.TAG)
+
+        do
+            local p = evo.spawn { [f2] = 21, [f3] = 'hello', [f4] = true }
+            local es, ec = evo.multi_clone(2, p, { [f1] = 'world', [f2] = 10 })
+            assert(#es == 2 and ec == 2)
+            for i = 1, ec do
+                assert(evo.alive(es[i]) and not evo.empty(es[i]) and evo.locate(es[i]) == evo.chunk(f1, f2, f3, f4))
+                assert(evo.has(es[i], f1) and evo.get(es[i], f1) == 'world')
+                assert(evo.has(es[i], f2) and evo.get(es[i], f2) == 10)
+                assert(evo.has(es[i], f3) and evo.get(es[i], f3) == true)
+                assert(evo.has(es[i], f4) and evo.get(es[i], f4) == nil)
+            end
+        end
+    end
+end
+
+do
+    local f1, f2, f3, f4 = evo.id(4)
+    evo.set(f1, evo.TAG)
+    evo.set(f1, evo.REQUIRES, { f2, f3 })
+    evo.set(f2, evo.DEFAULT, 42)
+    evo.set(f2, evo.DUPLICATE, function(v) return v * 2 end)
+    evo.set(f3, evo.DUPLICATE, function() return nil end)
+    evo.set(f4, evo.UNIQUE)
+
+    do
+        local p = evo.spawn { [f4] = 'unique' }
+        local es, ec = evo.multi_clone(3, p)
+        assert(#es == 3 and ec == 3)
+
+        for i = 1, ec do
+            assert(evo.alive(es[i]) and evo.empty(es[i]))
+        end
+    end
+
+    do
+        local p = evo.spawn { [f4] = 'unique' }
+        local es, ec = evo.multi_clone(3, p, {})
+        assert(#es == 3 and ec == 3)
+
+        for i = 1, ec do
+            assert(evo.alive(es[i]) and evo.empty(es[i]))
+        end
+    end
+
+    do
+        local p = evo.spawn { [f4] = 'unique' }
+        local es, ec = evo.multi_clone(2, p, { [f4] = 'another' })
+        assert(#es == 2 and ec == 2)
+
+        for i = 1, ec do
+            assert(evo.alive(es[i]) and not evo.empty(es[i]) and evo.locate(es[i]) == evo.chunk(f4))
+            assert(evo.has(es[i], f4) and evo.get(es[i], f4) == 'another')
+        end
+    end
+
+    do
+        local p = evo.spawn { [f2] = 100, [f4] = 'unique' }
+        local es, ec = evo.multi_clone(4, p, { [f4] = 'another' })
+        assert(#es == 4 and ec == 4)
+
+        for i = 1, ec do
+            assert(evo.alive(es[i]) and not evo.empty(es[i]) and evo.locate(es[i]) == evo.chunk(f2, f4))
+            assert(evo.has(es[i], f2) and evo.get(es[i], f2) == 200 * 2)
+            assert(evo.has(es[i], f4) and evo.get(es[i], f4) == 'another')
+        end
+    end
+
+    do
+        local p = evo.spawn { [f2] = 100, [f4] = 'unique' }
+        local es, ec = evo.multi_clone(5, p, { [f1] = 'hello', [f2] = 10 })
+        assert(#es == 5 and ec == 5)
+
+        for i = 1, ec do
+            assert(evo.alive(es[i]) and not evo.empty(es[i]) and evo.locate(es[i]) == evo.chunk(f1, f2, f3))
+            assert(evo.has(es[i], f1) and evo.get(es[i], f1) == nil)
+            assert(evo.has(es[i], f2) and evo.get(es[i], f2) == 10 * 2)
+            assert(evo.has(es[i], f3) and evo.get(es[i], f3) == true)
+        end
+    end
+
+    local f1_set_count, f1_inserted_count = 0, 0
+    local f2_set_sum, f3_inserted_count = 0, 0
+
+    evo.set(f1, evo.ON_SET, function(e, f, c)
+        assert(evo.get(e, f) == c)
+        f1_set_count = f1_set_count + 1
+    end)
+
+    evo.set(f1, evo.ON_INSERT, function(e, f, c)
+        assert(evo.get(e, f) == c)
+        f1_inserted_count = f1_inserted_count + 1
+    end)
+
+    evo.set(f2, evo.ON_SET, function(e, f, c)
+        assert(evo.get(e, f) == c)
+        f2_set_sum = f2_set_sum + c
+    end)
+
+    evo.set(f3, evo.ON_INSERT, function(e, f, c)
+        assert(evo.get(e, f) == c)
+        f3_inserted_count = f3_inserted_count + 1
+    end)
+
+    do
+        f1_set_count, f1_inserted_count = 0, 0
+        f2_set_sum, f3_inserted_count = 0, 0
+
+        local p = evo.spawn { [f2] = 100, [f4] = 'unique' }
+        local es, ec = evo.multi_clone(1, p, { [f1] = 'hello', [f2] = 10 })
+
+        for i = 1, ec do
+            assert(evo.alive(es[i]) and not evo.empty(es[i]) and evo.locate(es[i]) == evo.chunk(f1, f2, f3))
+            assert(evo.has(es[i], f1) and evo.get(es[i], f1) == nil)
+            assert(evo.has(es[i], f2) and evo.get(es[i], f2) == 10 * 2)
+            assert(evo.has(es[i], f3) and evo.get(es[i], f3) == true)
+
+            assert(f1_set_count == 1)
+            assert(f1_inserted_count == 1)
+            assert(f2_set_sum == 100 * 2 + 10 * 2)
+            assert(f3_inserted_count == 1)
+        end
+    end
+end
--- a/develop/testing/locate_tests.lua
+++ b/develop/testing/locate_tests.lua
@@ -0,0 +1,48 @@
+local evo = require 'evolved'
+
+do
+    local e1, e2, f1, f2 = evo.id(4)
+
+    do
+        local chunk, place = evo.locate(e1)
+        assert(chunk == nil and place == 0)
+    end
+
+    evo.set(e1, f1, 42)
+
+    do
+        local chunk, place = evo.locate(e1)
+        assert(chunk and chunk == evo.chunk(f1) and place == 1)
+        assert(chunk:components(f1)[place] == 42)
+
+        chunk, place = evo.locate(e2)
+        assert(chunk == nil and place == 0)
+    end
+
+    evo.set(e1, f2, 'hello')
+
+    do
+        local chunk, place = evo.locate(e1)
+        assert(chunk and chunk == evo.chunk(f1, f2) and place == 1)
+        assert(chunk:components(f1)[place] == 42)
+        assert(chunk:components(f2)[place] == 'hello')
+
+        chunk, place = evo.locate(e2)
+        assert(chunk == nil and place == 0)
+    end
+
+    evo.set(e2, f1, 84)
+    evo.set(e2, f2, 'world')
+
+    do
+        local chunk, place = evo.locate(e1)
+        assert(chunk and chunk == evo.chunk(f1, f2) and place == 1)
+        assert(chunk:components(f1)[place] == 42)
+        assert(chunk:components(f2)[place] == 'hello')
+
+        chunk, place = evo.locate(e2)
+        assert(chunk and chunk == evo.chunk(f1, f2) and place == 2)
+        assert(chunk:components(f1)[place] == 84)
+        assert(chunk:components(f2)[place] == 'world')
+    end
+end
--- a/develop/testing/main_tests.lua
+++ b/develop/testing/main_tests.lua
--- a/develop/testing/multi_spawn_tests.lua
+++ b/develop/testing/multi_spawn_tests.lua
@@ -0,0 +1,607 @@
+local evo = require 'evolved'
+
+do
+    local entity_list
+
+    do
+        entity_list = evo.multi_spawn(0)
+        assert(entity_list and #entity_list == 0)
+
+        entity_list = evo.multi_spawn(0, {})
+        assert(entity_list and #entity_list == 0)
+    end
+
+    do
+        entity_list = evo.multi_spawn(-1)
+        assert(entity_list and #entity_list == 0)
+
+        entity_list = evo.multi_spawn(-1, {})
+        assert(entity_list and #entity_list == 0)
+    end
+
+    do
+        entity_list = evo.builder():multi_spawn(0)
+        assert(entity_list and #entity_list == 0)
+    end
+
+    do
+        entity_list = evo.builder():multi_spawn(-1)
+        assert(entity_list and #entity_list == 0)
+    end
+end
+
+do
+    local entity_list
+
+    do
+        entity_list = evo.multi_spawn(1)
+        assert(entity_list and #entity_list == 1)
+        assert(entity_list[1] and evo.empty(entity_list[1]))
+        assert(not entity_list[2])
+
+        entity_list = evo.multi_spawn(1, {})
+        assert(entity_list and #entity_list == 1)
+        assert(entity_list[1] and evo.empty(entity_list[1]))
+        assert(not entity_list[2])
+    end
+
+    do
+        entity_list = evo.multi_spawn(2)
+        assert(entity_list and #entity_list == 2)
+        assert(entity_list[1] and evo.empty(entity_list[1]))
+        assert(entity_list[2] and evo.empty(entity_list[2]))
+        assert(not entity_list[3])
+
+        entity_list = evo.multi_spawn(2, {})
+        assert(entity_list and #entity_list == 2)
+        assert(entity_list[1] and evo.empty(entity_list[1]))
+        assert(entity_list[2] and evo.empty(entity_list[2]))
+        assert(not entity_list[3])
+    end
+
+    do
+        entity_list = evo.builder():multi_spawn(1)
+        assert(entity_list and #entity_list == 1)
+        assert(entity_list[1] and evo.empty(entity_list[1]))
+        assert(not entity_list[2])
+    end
+
+    do
+        entity_list = evo.builder():multi_spawn(2)
+        assert(entity_list and #entity_list == 2)
+        assert(entity_list[1] and evo.empty(entity_list[1]))
+        assert(entity_list[2] and evo.empty(entity_list[2]))
+        assert(not entity_list[3])
+    end
+end
+
+do
+    local entity_list
+
+    local prefab = evo.id()
+
+    do
+        entity_list = evo.multi_clone(0, prefab)
+        assert(entity_list and #entity_list == 0)
+
+        entity_list = evo.multi_clone(0, prefab, {})
+        assert(entity_list and #entity_list == 0)
+    end
+
+    do
+        entity_list = evo.multi_clone(-1, prefab)
+        assert(entity_list and #entity_list == 0)
+
+        entity_list = evo.multi_clone(-1, prefab, {})
+        assert(entity_list and #entity_list == 0)
+    end
+
+    do
+        entity_list = evo.builder():multi_clone(0, prefab)
+        assert(entity_list and #entity_list == 0)
+    end
+
+    do
+        entity_list = evo.builder():multi_clone(-1, prefab)
+        assert(entity_list and #entity_list == 0)
+    end
+end
+
+do
+    local entity_list
+
+    local prefab = evo.id()
+
+    do
+        entity_list = evo.multi_clone(1, prefab)
+        assert(entity_list and #entity_list == 1)
+        assert(entity_list[1] and evo.empty(entity_list[1]))
+        assert(not entity_list[2])
+
+        entity_list = evo.multi_clone(1, prefab, {})
+        assert(entity_list and #entity_list == 1)
+        assert(entity_list[1] and evo.empty(entity_list[1]))
+        assert(not entity_list[2])
+    end
+
+    do
+        entity_list = evo.multi_clone(2, prefab)
+        assert(entity_list and #entity_list == 2)
+        assert(entity_list[1] and evo.empty(entity_list[1]))
+        assert(entity_list[2] and evo.empty(entity_list[2]))
+        assert(not entity_list[3])
+
+        entity_list = evo.multi_clone(2, prefab, {})
+        assert(entity_list and #entity_list == 2)
+        assert(entity_list[1] and evo.empty(entity_list[1]))
+        assert(entity_list[2] and evo.empty(entity_list[2]))
+        assert(not entity_list[3])
+    end
+
+    do
+        entity_list = evo.builder():multi_clone(1, prefab)
+        assert(entity_list and #entity_list == 1)
+        assert(entity_list[1] and evo.empty(entity_list[1]))
+        assert(not entity_list[2])
+    end
+
+    do
+        entity_list = evo.builder():multi_clone(2, prefab)
+        assert(entity_list and #entity_list == 2)
+        assert(entity_list[1] and evo.empty(entity_list[1]))
+        assert(entity_list[2] and evo.empty(entity_list[2]))
+        assert(not entity_list[3])
+    end
+end
+
+do
+    local f1, f2 = evo.id(2)
+
+    do
+        local entity_list
+
+        entity_list = evo.multi_spawn(2, { [f1] = true, [f2] = 123 })
+        assert(entity_list and #entity_list == 2)
+        assert(entity_list[1] and evo.get(entity_list[1], f1) == true and evo.get(entity_list[1], f2) == 123)
+        assert(entity_list[2] and evo.get(entity_list[2], f1) == true and evo.get(entity_list[2], f2) == 123)
+
+        entity_list = evo.multi_spawn(2, { [f1] = false, [f2] = 456 })
+        assert(entity_list and #entity_list == 2)
+        assert(entity_list[1] and evo.get(entity_list[1], f1) == false and evo.get(entity_list[1], f2) == 456)
+        assert(entity_list[2] and evo.get(entity_list[2], f1) == false and evo.get(entity_list[2], f2) == 456)
+    end
+
+    do
+        local prefab = evo.builder():set(f1, true):set(f2, 123):spawn()
+
+        local entity_list
+
+        entity_list = evo.multi_clone(2, prefab)
+        assert(entity_list and #entity_list == 2)
+        assert(entity_list[1] and evo.get(entity_list[1], f1) == true and evo.get(entity_list[1], f2) == 123)
+        assert(entity_list[2] and evo.get(entity_list[2], f1) == true and evo.get(entity_list[2], f2) == 123)
+
+        entity_list = evo.multi_clone(2, prefab, {})
+        assert(entity_list and #entity_list == 2)
+        assert(entity_list[1] and evo.get(entity_list[1], f1) == true and evo.get(entity_list[1], f2) == 123)
+        assert(entity_list[2] and evo.get(entity_list[2], f1) == true and evo.get(entity_list[2], f2) == 123)
+
+        entity_list = evo.multi_clone(2, prefab, { [f1] = false, [f2] = 456 })
+        assert(entity_list and #entity_list == 2)
+        assert(entity_list[1] and evo.get(entity_list[1], f1) == false and evo.get(entity_list[1], f2) == 456)
+        assert(entity_list[2] and evo.get(entity_list[2], f1) == false and evo.get(entity_list[2], f2) == 456)
+    end
+end
+
+do
+    local f1, f2, f3 = evo.id(3)
+
+    do
+        local entity_list1, entity_list2
+
+        evo.defer()
+        do
+            entity_list1 = evo.multi_spawn(2, { [f1] = 42, [f2] = "hello", [f3] = false })
+            assert(entity_list1 and #entity_list1 == 2)
+            assert(entity_list1[1] and evo.empty(entity_list1[1]))
+            assert(entity_list1[2] and evo.empty(entity_list1[2]))
+            assert(not entity_list1[3])
+
+            entity_list2 = evo.multi_spawn(3, { [f2] = "world", [f3] = true })
+            assert(entity_list2 and #entity_list2 == 3)
+            assert(entity_list2[1] and evo.empty(entity_list2[1]))
+            assert(entity_list2[2] and evo.empty(entity_list2[2]))
+            assert(entity_list2[3] and evo.empty(entity_list2[3]))
+        end
+        evo.commit()
+        do
+            assert(entity_list1 and #entity_list1 == 2)
+            assert(entity_list1[1] and not evo.empty(entity_list1[1]))
+            assert(entity_list1[2] and not evo.empty(entity_list1[2]))
+            assert(not entity_list1[3])
+            assert(
+                evo.get(entity_list1[1], f1) == 42 and
+                evo.get(entity_list1[1], f2) == "hello" and
+                evo.get(entity_list1[1], f3) == false)
+            assert(
+                evo.get(entity_list1[2], f1) == 42 and
+                evo.get(entity_list1[2], f2) == "hello" and
+                evo.get(entity_list1[2], f3) == false)
+
+            assert(entity_list2 and #entity_list2 == 3)
+            assert(entity_list2[1] and not evo.empty(entity_list2[1]))
+            assert(entity_list2[2] and not evo.empty(entity_list2[2]))
+            assert(entity_list2[3] and not evo.empty(entity_list2[3]))
+            assert(not entity_list2[4])
+            assert(
+                evo.get(entity_list2[1], f1) == nil and
+                evo.get(entity_list2[1], f2) == "world" and
+                evo.get(entity_list2[1], f3) == true)
+            assert(
+                evo.get(entity_list2[2], f1) == nil and
+                evo.get(entity_list2[2], f2) == "world" and
+                evo.get(entity_list2[2], f3) == true)
+            assert(
+                evo.get(entity_list2[3], f1) == nil and
+                evo.get(entity_list2[3], f2) == "world" and
+                evo.get(entity_list2[3], f3) == true)
+        end
+    end
+end
+
+do
+    local f1, f2, f3 = evo.id(3)
+
+    do
+        local prefab = evo.builder():set(f1, false):set(f2, 123):spawn()
+
+        local entity_list1, entity_list2
+
+        evo.defer()
+        do
+            entity_list1 = evo.multi_clone(2, prefab)
+            assert(entity_list1 and #entity_list1 == 2)
+            assert(entity_list1[1] and evo.empty(entity_list1[1]))
+            assert(entity_list1[2] and evo.empty(entity_list1[2]))
+            assert(not entity_list1[3])
+
+            entity_list2 = evo.multi_clone(3, prefab, { [f2] = 456, [f3] = "world" })
+            assert(entity_list2 and #entity_list2 == 3)
+            assert(entity_list2[1] and evo.empty(entity_list2[1]))
+            assert(entity_list2[2] and evo.empty(entity_list2[2]))
+            assert(entity_list2[3] and evo.empty(entity_list2[3]))
+        end
+        evo.commit()
+        do
+            assert(entity_list1 and #entity_list1 == 2)
+            assert(entity_list1[1] and not evo.empty(entity_list1[1]))
+            assert(entity_list1[2] and not evo.empty(entity_list1[2]))
+            assert(not entity_list1[3])
+            assert(
+                evo.get(entity_list1[1], f1) == false and
+                evo.get(entity_list1[1], f2) == 123 and
+                evo.get(entity_list1[1], f3) == nil)
+            assert(
+                evo.get(entity_list1[2], f1) == false and
+                evo.get(entity_list1[2], f2) == 123 and
+                evo.get(entity_list1[2], f3) == nil)
+
+            assert(entity_list2 and #entity_list2 == 3)
+            assert(entity_list2[1] and not evo.empty(entity_list2[1]))
+            assert(entity_list2[2] and not evo.empty(entity_list2[2]))
+            assert(entity_list2[3] and not evo.empty(entity_list2[3]))
+            assert(not entity_list2[4])
+            assert(
+                evo.get(entity_list2[1], f1) == false and
+                evo.get(entity_list2[1], f2) == 456 and
+                evo.get(entity_list2[1], f3) == "world")
+            assert(
+                evo.get(entity_list2[2], f1) == false and
+                evo.get(entity_list2[2], f2) == 456 and
+                evo.get(entity_list2[2], f3) == "world")
+            assert(
+                evo.get(entity_list2[3], f1) == false and
+                evo.get(entity_list2[3], f2) == 456 and
+                evo.get(entity_list2[3], f3) == "world")
+        end
+    end
+end
+
+do
+    local f1, f2, f3 = evo.id(3)
+
+    evo.set(f1, evo.REQUIRES, { f2, f3 })
+    evo.set(f3, evo.TAG)
+
+    do
+        local entity_list, entity_count = evo.multi_spawn(2, { [f1] = 42 })
+
+        assert(entity_list and #entity_list == 2)
+        assert(entity_count == 2)
+
+        for i = 1, entity_count do
+            local e = entity_list[i]
+            assert(e and not evo.empty(e))
+
+            assert(evo.has(e, f1) and evo.get(e, f1) == 42)
+            assert(evo.has(e, f2) and evo.get(e, f2) == true)
+            assert(evo.has(e, f3) and evo.get(e, f3) == nil)
+        end
+    end
+
+    do
+        local entity_prefab = evo.builder():set(f1, 42):spawn()
+
+        local clone_list, clone_count = evo.multi_clone(2, entity_prefab)
+
+        assert(clone_list and #clone_list == 2)
+        assert(clone_count == 2)
+
+        for i = 1, clone_count do
+            local e = clone_list[i]
+            assert(e and not evo.empty(e))
+
+            assert(evo.has(e, f1) and evo.get(e, f1) == 42)
+            assert(evo.has(e, f2) and evo.get(e, f2) == true)
+            assert(evo.has(e, f3) and evo.get(e, f3) == nil)
+        end
+    end
+
+    do
+        local entity_prefab = evo.builder():set(f1, 42):spawn()
+        evo.remove(entity_prefab, f2, f3)
+
+        local clone_list, clone_count = evo.multi_clone(2, entity_prefab, { [f1] = 21 })
+
+        assert(clone_list and #clone_list == 2)
+        assert(clone_count == 2)
+
+        for i = 1, clone_count do
+            local e = clone_list[i]
+            assert(e and not evo.empty(e))
+
+            assert(evo.has(e, f1) and evo.get(e, f1) == 21)
+            assert(evo.has(e, f2) and evo.get(e, f2) == true)
+            assert(evo.has(e, f3) and evo.get(e, f3) == nil)
+        end
+    end
+
+    evo.set(f2, evo.DEFAULT, false)
+
+    do
+        local entity_list, entity_count = evo.multi_spawn(2, { [f1] = 42 })
+
+        assert(entity_list and #entity_list == 2)
+        assert(entity_count == 2)
+
+        for i = 1, entity_count do
+            local e = entity_list[i]
+            assert(e and not evo.empty(e))
+
+            assert(evo.has(e, f1) and evo.get(e, f1) == 42)
+            assert(evo.has(e, f2) and evo.get(e, f2) == false)
+            assert(evo.has(e, f3) and evo.get(e, f3) == nil)
+        end
+    end
+
+    do
+        local entity_prefab = evo.builder():set(f1, 42):spawn()
+
+        local clone_list, clone_count = evo.multi_clone(2, entity_prefab)
+
+        assert(clone_list and #clone_list == 2)
+        assert(clone_count == 2)
+
+        for i = 1, clone_count do
+            local e = clone_list[i]
+            assert(e and not evo.empty(e))
+
+            assert(evo.has(e, f1) and evo.get(e, f1) == 42)
+            assert(evo.has(e, f2) and evo.get(e, f2) == false)
+            assert(evo.has(e, f3) and evo.get(e, f3) == nil)
+        end
+    end
+
+    do
+        local entity_prefab = evo.builder():set(f1, 42):spawn()
+        evo.remove(entity_prefab, f2, f3)
+
+        local clone_list, clone_count = evo.multi_clone(2, entity_prefab, { [f1] = 21 })
+
+        assert(clone_list and #clone_list == 2)
+        assert(clone_count == 2)
+
+        for i = 1, clone_count do
+            local e = clone_list[i]
+            assert(e and not evo.empty(e))
+
+            assert(evo.has(e, f1) and evo.get(e, f1) == 21)
+            assert(evo.has(e, f2) and evo.get(e, f2) == false)
+            assert(evo.has(e, f3) and evo.get(e, f3) == nil)
+        end
+    end
+
+    local v_set_sum = 0
+    local v_insert_sum = 0
+
+    local f3_set_times = 0
+    local f3_insert_times = 0
+
+    evo.set(f1, evo.ON_SET, function(e, f, v)
+        assert(f == f1)
+        v_set_sum = v_set_sum + v
+        assert(evo.get(e, f) == v)
+    end)
+
+    evo.set(f1, evo.ON_INSERT, function(e, f, v)
+        assert(f == f1)
+        v_insert_sum = v_insert_sum + v
+        assert(evo.get(e, f) == v)
+    end)
+
+    evo.set(f3, evo.ON_SET, function(e, f, v)
+        assert(f == f3)
+        f3_set_times = f3_set_times + 1
+        assert(v == nil)
+        assert(evo.has(e, f))
+    end)
+
+    evo.set(f3, evo.ON_INSERT, function(e, f, v)
+        assert(f == f3)
+        f3_insert_times = f3_insert_times + 1
+        assert(v == nil)
+        assert(evo.has(e, f))
+    end)
+
+    do
+        local entity_list, entity_count = evo.multi_spawn(2, { [f1] = 42 })
+
+        assert(entity_list and #entity_list == 2)
+        assert(entity_count == 2)
+
+        for i = 1, entity_count do
+            local e = entity_list[i]
+            assert(e and not evo.empty(e))
+
+            assert(evo.has(e, f1) and evo.get(e, f1) == 42)
+            assert(evo.has(e, f2) and evo.get(e, f2) == false)
+        end
+    end
+
+    do
+        local entity_prefab = evo.builder():set(f1, 42):spawn()
+
+        local clone_list, clone_count = evo.multi_clone(2, entity_prefab)
+
+        assert(clone_list and #clone_list == 2)
+        assert(clone_count == 2)
+
+        for i = 1, clone_count do
+            local e = clone_list[i]
+            assert(e and not evo.empty(e))
+
+            assert(evo.has(e, f1) and evo.get(e, f1) == 42)
+            assert(evo.has(e, f2) and evo.get(e, f2) == false)
+        end
+    end
+
+    do
+        local entity_prefab = evo.builder():set(f1, 42):spawn()
+        evo.remove(entity_prefab, f2, f3)
+
+        local clone_list, clone_count = evo.multi_clone(2, entity_prefab, { [f1] = 21 })
+
+        assert(clone_list and #clone_list == 2)
+        assert(clone_count == 2)
+
+        for i = 1, clone_count do
+            local e = clone_list[i]
+            assert(e and not evo.empty(e))
+
+            assert(evo.has(e, f1) and evo.get(e, f1) == 21)
+            assert(evo.has(e, f2) and evo.get(e, f2) == false)
+        end
+    end
+
+    assert(v_set_sum == 42 * 6 + 21 * 2)
+    assert(v_insert_sum == 42 * 6 + 21 * 2)
+
+    assert(f3_set_times == 8)
+    assert(f3_insert_times == 8)
+end
+
+do
+    local function v2(x, y) return { x = x or 0, y = y or 0 } end
+    local function v2_clone(v) return { x = v.x, y = v.y } end
+
+    local f1, f2, f3, f4 = evo.id(4)
+    evo.set(f1, evo.REQUIRES, { f2, f3, f4 })
+
+    local f1_default = v2(1, 2)
+    local f2_default = v2(3, 4)
+    local f3_default = v2(10, 11)
+    local f4_default = v2(12, 13)
+
+    evo.set(f1, evo.DEFAULT, f1_default)
+    evo.set(f2, evo.DEFAULT, f2_default)
+    evo.set(f3, evo.DEFAULT, f3_default)
+    evo.set(f4, evo.DEFAULT, f4_default)
+
+    evo.set(f1, evo.DUPLICATE, v2_clone)
+    evo.set(f2, evo.DUPLICATE, v2_clone)
+    evo.set(f3, evo.DUPLICATE, v2_clone)
+
+    do
+        local entity_list, entity_count = evo.multi_spawn(2, { [f1] = v2(5, 6), [f2] = v2(7, 8) })
+
+        assert(entity_list and #entity_list == 2)
+        assert(entity_count == 2)
+
+        for i = 1, entity_count do
+            local e = entity_list[i]
+            assert(e and not evo.empty(e))
+
+            assert(evo.has(e, f1) and evo.get(e, f1) ~= f1_default)
+            assert(evo.get(e, f1).x == 5 and evo.get(e, f1).y == 6)
+
+            assert(evo.has(e, f2) and evo.get(e, f2) ~= f2_default)
+            assert(evo.get(e, f2).x == 7 and evo.get(e, f2).y == 8)
+
+            assert(evo.has(e, f3) and evo.get(e, f3) ~= f3_default)
+            assert(evo.get(e, f3).x == 10 and evo.get(e, f3).y == 11)
+
+            assert(evo.has(e, f4) and evo.get(e, f4) == f4_default)
+        end
+    end
+
+    do
+        local entity_prefab = evo.builder():set(f1, v2(5, 6)):set(f2, v2(7, 8)):spawn()
+
+        local clone_list, clone_count = evo.multi_clone(2, entity_prefab, { [f2] = f2_default })
+
+        assert(clone_list and #clone_list == 2)
+        assert(clone_count == 2)
+
+        for i = 1, clone_count do
+            local e = clone_list[i]
+            assert(e and not evo.empty(e))
+
+            assert(evo.has(e, f1) and evo.get(e, f1) ~= f1_default and evo.get(e, f1) ~= evo.get(entity_prefab, f1))
+            assert(evo.get(e, f1).x == 5 and evo.get(e, f1).y == 6)
+
+            assert(evo.has(e, f2) and evo.get(e, f2) ~= f2_default and evo.get(e, f2) ~= evo.get(entity_prefab, f2))
+            assert(evo.get(e, f2).x == 3 and evo.get(e, f2).y == 4)
+
+            assert(evo.has(e, f3) and evo.get(e, f3) ~= f3_default)
+            assert(evo.get(e, f3).x == 10 and evo.get(e, f3).y == 11)
+
+            assert(evo.has(e, f4) and evo.get(e, f4) == f4_default)
+        end
+    end
+
+    do
+        local entity_prefab = evo.builder():set(f1, v2(5, 6)):set(f2, v2(7, 8)):spawn()
+        evo.remove(entity_prefab, f2, f3, f4)
+
+        local clone_list, clone_count = evo.multi_clone(2, entity_prefab, { [f2] = f2_default })
+
+        assert(clone_list and #clone_list == 2)
+        assert(clone_count == 2)
+
+        for i = 1, clone_count do
+            local e = clone_list[i]
+            assert(e and not evo.empty(e))
+
+            assert(evo.has(e, f1) and evo.get(e, f1) ~= f1_default and evo.get(e, f1) ~= evo.get(entity_prefab, f1))
+            assert(evo.get(e, f1).x == 5 and evo.get(e, f1).y == 6)
+
+            assert(evo.has(e, f2) and evo.get(e, f2) ~= f2_default and evo.get(e, f2) ~= evo.get(entity_prefab, f2))
+            assert(evo.get(e, f2).x == 3 and evo.get(e, f2).y == 4)
+
+            assert(evo.has(e, f3) and evo.get(e, f3) ~= f3_default)
+            assert(evo.get(e, f3).x == 10 and evo.get(e, f3).y == 11)
+
+            assert(evo.has(e, f4) and evo.get(e, f4) == f4_default)
+        end
+    end
+end
--- a/develop/testing/spawn_tests.lua
+++ b/develop/testing/spawn_tests.lua
@@ -0,0 +1,329 @@
+local evo = require 'evolved'
+
+do
+    do
+        local e = evo.spawn()
+        assert(evo.alive(e) and evo.empty(e))
+    end
+
+    do
+        local e = evo.spawn({})
+        assert(evo.alive(e) and evo.empty(e))
+    end
+end
+
+do
+    local f1, f2, f3 = evo.id(3)
+    evo.set(f2, evo.REQUIRES, { f1, f3 })
+
+    do
+        local e = evo.spawn({ [f1] = 42 })
+        assert(evo.alive(e) and not evo.empty(e) and evo.locate(e) == evo.chunk(f1))
+        assert(evo.has(e, f1) and evo.get(e, f1) == 42)
+    end
+
+    do
+        local e = evo.spawn({ [f1] = 42, [f2] = 'hello' })
+        assert(evo.alive(e) and not evo.empty(e) and evo.locate(e) == evo.chunk(f1, f2, f3))
+        assert(evo.has(e, f1) and evo.get(e, f1) == 42)
+        assert(evo.has(e, f2) and evo.get(e, f2) == 'hello')
+        assert(evo.has(e, f3) and evo.get(e, f3) == true)
+    end
+end
+
+do
+    local f1, f2, f3 = evo.id(3)
+    evo.set(f2, evo.REQUIRES, { f1, f3 })
+    evo.set(f3, evo.DEFAULT, 21)
+    evo.set(f3, evo.REQUIRES, { f2 })
+
+    do
+        local e = evo.spawn({ [f1] = 42 })
+        assert(evo.alive(e) and not evo.empty(e) and evo.locate(e) == evo.chunk(f1))
+        assert(evo.has(e, f1) and evo.get(e, f1) == 42)
+    end
+
+    do
+        local e = evo.spawn({ [f1] = 42, [f2] = 'hello' })
+        assert(evo.alive(e) and not evo.empty(e) and evo.locate(e) == evo.chunk(f1, f2, f3))
+        assert(evo.has(e, f1) and evo.get(e, f1) == 42)
+        assert(evo.has(e, f2) and evo.get(e, f2) == 'hello')
+        assert(evo.has(e, f3) and evo.get(e, f3) == 21)
+    end
+end
+
+do
+    local f1, f2, f3, f4 = evo.id(4)
+    evo.set(f2, evo.DUPLICATE, function() return nil end)
+    evo.set(f2, evo.REQUIRES, { f1, f3, f4 })
+    evo.set(f3, evo.DEFAULT, 21)
+    evo.set(f3, evo.DUPLICATE, function(v) return v * 3 end)
+    evo.set(f3, evo.REQUIRES, { f2 })
+
+    do
+        local e = evo.spawn({ [f1] = 42 })
+        assert(evo.alive(e) and not evo.empty(e) and evo.locate(e) == evo.chunk(f1))
+        assert(evo.has(e, f1) and evo.get(e, f1) == 42)
+    end
+
+    do
+        local e = evo.spawn({ [f1] = 42, [f2] = true })
+        assert(evo.alive(e) and not evo.empty(e) and evo.locate(e) == evo.chunk(f1, f2, f3, f4))
+        assert(evo.has(e, f1) and evo.get(e, f1) == 42)
+        assert(evo.has(e, f2) and evo.get(e, f2) == true)
+        assert(evo.has(e, f3) and evo.get(e, f3) == 21 * 3)
+        assert(evo.has(e, f4) and evo.get(e, f4) == true)
+    end
+end
+
+do
+    local f1, f2, f3 = evo.id(3)
+    evo.set(f2, evo.REQUIRES, { f3 })
+    evo.set(f3, evo.TAG)
+
+    local f2_set_sum, f2_inserted_sum = 0, 0
+    local f3_set_count, f3_inserted_count = 0, 0
+
+    evo.set(f2, evo.ON_SET, function(e, f, c)
+        assert(c == 42)
+        assert(evo.get(e, f) == c)
+        assert(f == f2)
+        f2_set_sum = f2_set_sum + c
+    end)
+
+    evo.set(f2, evo.ON_INSERT, function(e, f, c)
+        assert(c == 42)
+        assert(evo.get(e, f) == c)
+        assert(f == f2)
+        f2_inserted_sum = f2_inserted_sum + c
+    end)
+
+    evo.set(f3, evo.ON_SET, function(e, f, c)
+        assert(c == nil)
+        assert(evo.get(e, f) == c)
+        assert(f == f3)
+        f3_set_count = f3_set_count + 1
+    end)
+
+    evo.set(f3, evo.ON_INSERT, function(e, f, c)
+        assert(c == nil)
+        assert(evo.get(e, f) == c)
+        assert(f == f3)
+        f3_inserted_count = f3_inserted_count + 1
+    end)
+
+    do
+        f3_set_count, f3_inserted_count = 0, 0
+        local e = evo.spawn({ [f1] = 'hello', [f2] = 42 })
+        assert(evo.alive(e) and not evo.empty(e) and evo.locate(e) == evo.chunk(f1, f2, f3))
+        assert(f2_set_sum == 42 and f2_inserted_sum == 42)
+        assert(f3_set_count == 1 and f3_inserted_count == 1)
+    end
+end
+
+do
+    do
+        local es, ec = evo.multi_spawn(2)
+        assert(#es == 2 and ec == 2)
+
+        for i = 1, ec do
+            assert(evo.alive(es[i]) and evo.empty(es[i]))
+        end
+    end
+
+    do
+        local es, ec = evo.multi_spawn(2, {})
+        assert(#es == 2 and ec == 2)
+
+        for i = 1, ec do
+            assert(evo.alive(es[i]) and evo.empty(es[i]))
+        end
+    end
+end
+
+do
+    local f1, f2 = evo.id(2)
+
+    do
+        local es, ec = evo.multi_spawn(3, { [f1] = 42 })
+        assert(#es == 3 and ec == 3)
+
+        for i = 1, ec do
+            assert(evo.alive(es[i]) and not evo.empty(es[i]) and evo.locate(es[i]) == evo.chunk(f1))
+            assert(evo.has(es[i], f1) and evo.get(es[i], f1) == 42)
+        end
+    end
+
+    do
+        local es, ec = evo.multi_spawn(3, { [f1] = 42, [f2] = 'hello' })
+        assert(#es == 3 and ec == 3)
+
+        for i = 1, ec do
+            assert(evo.alive(es[i]) and not evo.empty(es[i]) and evo.locate(es[i]) == evo.chunk(f1, f2))
+            assert(evo.has(es[i], f1) and evo.get(es[i], f1) == 42)
+            assert(evo.has(es[i], f2) and evo.get(es[i], f2) == 'hello')
+        end
+    end
+end
+
+do
+    local f1, f2 = evo.id(2)
+    evo.set(f1, evo.REQUIRES, { f2 })
+
+    do
+        local es, ec = evo.multi_spawn(3, { [f1] = 42 })
+        assert(#es == 3 and ec == 3)
+
+        for i = 1, ec do
+            assert(evo.alive(es[i]) and not evo.empty(es[i]) and evo.locate(es[i]) == evo.chunk(f1, f2))
+            assert(evo.has(es[i], f1) and evo.get(es[i], f1) == 42)
+            assert(evo.has(es[i], f2) and evo.get(es[i], f2) == true)
+        end
+    end
+end
+
+do
+    local f1, f2 = evo.id(2)
+    evo.set(f1, evo.REQUIRES, { f2 })
+
+    do
+        local es, ec = evo.multi_spawn(1, { [f1] = 42 })
+        assert(#es == 1 and ec == 1)
+
+        for i = 1, ec do
+            assert(evo.alive(es[i]) and not evo.empty(es[i]) and evo.locate(es[i]) == evo.chunk(f1, f2))
+            assert(evo.has(es[i], f1) and evo.get(es[i], f1) == 42)
+            assert(evo.has(es[i], f2) and evo.get(es[i], f2) == true)
+        end
+    end
+end
+
+do
+    local f1, f2, f3 = evo.id(3)
+    evo.set(f1, evo.REQUIRES, { f2, f3 })
+    evo.set(f2, evo.DEFAULT, 'hello')
+
+    do
+        local es, ec = evo.multi_spawn(4, { [f1] = 42 })
+        assert(#es == 4 and ec == 4)
+
+        for i = 1, ec do
+            assert(evo.alive(es[i]) and not evo.empty(es[i]) and evo.locate(es[i]) == evo.chunk(f1, f2, f3))
+            assert(evo.has(es[i], f1) and evo.get(es[i], f1) == 42)
+            assert(evo.has(es[i], f2) and evo.get(es[i], f2) == 'hello')
+            assert(evo.has(es[i], f3) and evo.get(es[i], f3) == true)
+        end
+    end
+
+    do
+        local es, ec = evo.multi_spawn(4, { [f1] = 42, [f2] = 'world' })
+        assert(#es == 4 and ec == 4)
+
+        for i = 1, ec do
+            assert(evo.alive(es[i]) and not evo.empty(es[i]) and evo.locate(es[i]) == evo.chunk(f1, f2, f3))
+            assert(evo.has(es[i], f1) and evo.get(es[i], f1) == 42)
+            assert(evo.has(es[i], f2) and evo.get(es[i], f2) == 'world')
+            assert(evo.has(es[i], f3) and evo.get(es[i], f3) == true)
+        end
+    end
+
+    do
+        local es, ec = evo.multi_spawn(4, { [f1] = 42, [f2] = 'world', [f3] = false })
+        assert(#es == 4 and ec == 4)
+
+        for i = 1, ec do
+            assert(evo.alive(es[i]) and not evo.empty(es[i]) and evo.locate(es[i]) == evo.chunk(f1, f2, f3))
+            assert(evo.has(es[i], f1) and evo.get(es[i], f1) == 42)
+            assert(evo.has(es[i], f2) and evo.get(es[i], f2) == 'world')
+            assert(evo.has(es[i], f3) and evo.get(es[i], f3) == false)
+        end
+    end
+end
+
+do
+    local f1, f2 = evo.id(2)
+    evo.set(f1, evo.REQUIRES, { f2 })
+    evo.set(f1, evo.DUPLICATE, function() return nil end)
+    evo.set(f2, evo.DEFAULT, 'hello')
+    evo.set(f2, evo.DUPLICATE, function(v) return v .. '!' end)
+
+    do
+        local es, ec = evo.multi_spawn(4, { [f1] = 42 })
+        assert(#es == 4 and ec == 4)
+
+        for i = 1, ec do
+            assert(evo.alive(es[i]) and not evo.empty(es[i]) and evo.locate(es[i]) == evo.chunk(f1, f2))
+            assert(evo.has(es[i], f1) and evo.get(es[i], f1) == true)
+            assert(evo.has(es[i], f2) and evo.get(es[i], f2) == 'hello!')
+        end
+    end
+
+    do
+        local es, ec = evo.multi_spawn(4, { [f1] = 42, [f2] = 'world' })
+        assert(#es == 4 and ec == 4)
+
+        for i = 1, ec do
+            assert(evo.alive(es[i]) and not evo.empty(es[i]) and evo.locate(es[i]) == evo.chunk(f1, f2))
+            assert(evo.has(es[i], f1) and evo.get(es[i], f1) == true)
+            assert(evo.has(es[i], f2) and evo.get(es[i], f2) == 'world!')
+        end
+    end
+
+    do
+        local es, ec = evo.multi_spawn(4, { [f2] = 'hello world' })
+        assert(#es == 4 and ec == 4)
+
+        for i = 1, ec do
+            assert(evo.alive(es[i]) and not evo.empty(es[i]) and evo.locate(es[i]) == evo.chunk(f2))
+            assert(evo.has(es[i], f2) and evo.get(es[i], f2) == 'hello world!')
+        end
+    end
+end
+
+do
+    local f1, f2, f3 = evo.id(3)
+    evo.set(f2, evo.REQUIRES, { f3 })
+    evo.set(f3, evo.TAG)
+
+    local f2_set_sum, f2_inserted_sum = 0, 0
+    local f3_set_count, f3_inserted_count = 0, 0
+
+    evo.set(f2, evo.ON_SET, function(e, f, c)
+        assert(c == 42)
+        assert(evo.get(e, f) == c)
+        assert(f == f2)
+        f2_set_sum = f2_set_sum + c
+    end)
+
+    evo.set(f2, evo.ON_INSERT, function(e, f, c)
+        assert(c == 42)
+        assert(evo.get(e, f) == c)
+        assert(f == f2)
+        f2_inserted_sum = f2_inserted_sum + c
+    end)
+
+    evo.set(f3, evo.ON_SET, function(e, f, c)
+        assert(c == nil)
+        assert(evo.get(e, f) == c)
+        assert(f == f3)
+        f3_set_count = f3_set_count + 1
+    end)
+
+    evo.set(f3, evo.ON_INSERT, function(e, f, c)
+        assert(c == nil)
+        assert(evo.get(e, f) == c)
+        assert(f == f3)
+        f3_inserted_count = f3_inserted_count + 1
+    end)
+
+    do
+        local es, ec = evo.multi_spawn(3, { [f1] = 'hello', [f2] = 42 })
+        assert(#es == 3 and ec == 3)
+
+        for i = 1, ec do
+            assert(evo.alive(es[i]) and not evo.empty(es[i]) and evo.locate(es[i]) == evo.chunk(f1, f2, f3))
+            assert(f2_set_sum == 42 * 3 and f2_inserted_sum == 42 * 3)
+            assert(f3_set_count == 3 and f3_inserted_count == 3)
+        end
+    end
+end
--- a/develop/unbench.lua
+++ b/develop/unbench.lua
@@ -1,860 +0,0 @@
-local basics = require 'develop.basics'
-basics.unload 'evolved'
-
-local evo = require 'evolved'
-
-local N = 1000
-local B = evo.builder()
-local F1, F2, F3, F4, F5 = evo.id(5)
-local Q1 = evo.builder():include(F1):spawn()
-local R1 = evo.builder():require(F1):spawn()
-local R2 = evo.builder():require(F1, F2):spawn()
-local R3 = evo.builder():require(F1, F2, F3):spawn()
-local R4 = evo.builder():require(F1, F2, F3, F4):spawn()
-local R5 = evo.builder():require(F1, F2, F3, F4, F5):spawn()
-
-print '----------------------------------------'
-
-basics.describe_bench(string.format('create %d tables', N),
-    ---@param tables table[]
-    function(tables)
-        for i = 1, N do
-            local t = {}
-            tables[i] = t
-        end
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and collect %d tables', N),
-    ---@param tables table[]
-    function(tables)
-        for i = 1, N do
-            local t = {}
-            tables[i] = t
-        end
-
-        for i = 1, #tables do
-            tables[i] = nil
-        end
-
-        collectgarbage('collect')
-    end, function()
-        return {}
-    end)
-
-print '----------------------------------------'
-
-basics.describe_bench(string.format('create %d tables with 1 component / AoS', N),
-    ---@param tables table
-    function(tables)
-        for i = 1, N do
-            local e = {}
-            e[F1] = true
-            tables[i] = e
-        end
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create %d tables with 2 component / AoS', N),
-    ---@param tables table
-    function(tables)
-        for i = 1, N do
-            local e = {}
-            e[F1] = true
-            e[F2] = true
-            tables[i] = e
-        end
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create %d tables with 3 component / AoS', N),
-    ---@param tables table
-    function(tables)
-        for i = 1, N do
-            local e = {}
-            e[F1] = true
-            e[F2] = true
-            e[F3] = true
-            tables[i] = e
-        end
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create %d tables with 4 component / AoS', N),
-    ---@param tables table
-    function(tables)
-        for i = 1, N do
-            local e = {}
-            e[F1] = true
-            e[F2] = true
-            e[F3] = true
-            e[F4] = true
-            tables[i] = e
-        end
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create %d tables with 5 component / AoS', N),
-    ---@param tables table
-    function(tables)
-        for i = 1, N do
-            local e = {}
-            e[F1] = true
-            e[F2] = true
-            e[F3] = true
-            e[F4] = true
-            e[F5] = true
-            tables[i] = e
-        end
-    end, function()
-        return {}
-    end)
-
-print '----------------------------------------'
-
-basics.describe_bench(string.format('create %d tables with 1 component / SoA', N),
-    ---@param tables table
-    function(tables)
-        local fs1 = {}
-        for i = 1, N do
-            local e = {}
-            fs1[i] = true
-            tables[i] = e
-        end
-        tables[F1] = fs1
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create %d tables with 2 component / SoA', N),
-    ---@param tables table
-    function(tables)
-        local fs1 = {}
-        local fs2 = {}
-        for i = 1, N do
-            local e = {}
-            fs1[i] = true
-            fs2[i] = true
-            tables[i] = e
-        end
-        tables[F1] = fs1
-        tables[F2] = fs2
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create %d tables with 3 component / SoA', N),
-    ---@param tables table
-    function(tables)
-        local fs1 = {}
-        local fs2 = {}
-        local fs3 = {}
-        for i = 1, N do
-            local e = {}
-            fs1[i] = true
-            fs2[i] = true
-            fs3[i] = true
-            tables[i] = e
-        end
-        tables[F1] = fs1
-        tables[F2] = fs2
-        tables[F3] = fs3
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create %d tables with 4 component / SoA', N),
-    ---@param tables table
-    function(tables)
-        local fs1 = {}
-        local fs2 = {}
-        local fs3 = {}
-        local fs4 = {}
-        for i = 1, N do
-            local e = {}
-            fs1[i] = i
-            fs2[i] = i
-            fs3[i] = i
-            fs4[i] = i
-            tables[i] = e
-        end
-        tables[F1] = fs1
-        tables[F2] = fs2
-        tables[F3] = fs3
-        tables[F4] = fs4
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create %d tables with 5 component / SoA', N),
-    ---@param tables table
-    function(tables)
-        local fs1 = {}
-        local fs2 = {}
-        local fs3 = {}
-        local fs4 = {}
-        local fs5 = {}
-        for i = 1, N do
-            local e = {}
-            fs1[i] = i
-            fs2[i] = i
-            fs3[i] = i
-            fs4[i] = i
-            fs5[i] = i
-            tables[i] = e
-        end
-        tables[F1] = fs1
-        tables[F2] = fs2
-        tables[F3] = fs3
-        tables[F4] = fs4
-        tables[F5] = fs5
-    end, function()
-        return {}
-    end)
-
-print '----------------------------------------'
-
-basics.describe_bench(string.format('create and destroy %d entities', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local id = evo.id
-        local destroy = evo.destroy
-
-        for i = 1, N do
-            local e = id()
-            entities[i] = e
-        end
-
-        for i = #entities, 1, -1 do
-            destroy(entities[i])
-        end
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 1 component', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local id = evo.id
-        local set = evo.set
-
-        for i = 1, N do
-            local e = id()
-            set(e, F1)
-            entities[i] = e
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 2 components', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local id = evo.id
-        local set = evo.set
-
-        for i = 1, N do
-            local e = id()
-            set(e, F1)
-            set(e, F2)
-            entities[i] = e
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 3 components', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local id = evo.id
-        local set = evo.set
-
-        for i = 1, N do
-            local e = id()
-            set(e, F1)
-            set(e, F2)
-            set(e, F3)
-            entities[i] = e
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 4 components', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local id = evo.id
-        local set = evo.set
-
-        for i = 1, N do
-            local e = id()
-            set(e, F1)
-            set(e, F2)
-            set(e, F3)
-            set(e, F4)
-            entities[i] = e
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 5 components', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local id = evo.id
-        local set = evo.set
-
-        for i = 1, N do
-            local e = id()
-            set(e, F1)
-            set(e, F2)
-            set(e, F3)
-            set(e, F4)
-            set(e, F5)
-            entities[i] = e
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-print '----------------------------------------'
-
-basics.describe_bench(string.format('create and destroy %d entities with 1 components / defer', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local id = evo.id
-        local set = evo.set
-
-        evo.defer()
-        for i = 1, N do
-            local e = id()
-            set(e, F1)
-            entities[i] = e
-        end
-        evo.commit()
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 2 components / defer', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local id = evo.id
-        local set = evo.set
-
-        evo.defer()
-        for i = 1, N do
-            local e = id()
-            set(e, F1)
-            set(e, F2)
-            entities[i] = e
-        end
-        evo.commit()
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 3 components / defer', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local id = evo.id
-        local set = evo.set
-
-        evo.defer()
-        for i = 1, N do
-            local e = id()
-            set(e, F1)
-            set(e, F2)
-            set(e, F3)
-            entities[i] = e
-        end
-        evo.commit()
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 4 components / defer', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local id = evo.id
-        local set = evo.set
-
-        evo.defer()
-        for i = 1, N do
-            local e = id()
-            set(e, F1)
-            set(e, F2)
-            set(e, F3)
-            set(e, F4)
-            entities[i] = e
-        end
-        evo.commit()
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 5 components / defer', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local id = evo.id
-        local set = evo.set
-
-        evo.defer()
-        for i = 1, N do
-            local e = id()
-            set(e, F1)
-            set(e, F2)
-            set(e, F3)
-            set(e, F4)
-            set(e, F5)
-            entities[i] = e
-        end
-        evo.commit()
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-print '----------------------------------------'
-
-basics.describe_bench(string.format('create and destroy %d entities with 1 components / builder', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local set = B.set
-        local spawn = B.spawn
-
-        for i = 1, N do
-            set(B, F1)
-            entities[i] = spawn(B)
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 2 components / builder', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local set = B.set
-        local spawn = B.spawn
-
-        for i = 1, N do
-            set(B, F1)
-            set(B, F2)
-            entities[i] = spawn(B)
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 3 components / builder', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local set = B.set
-        local spawn = B.spawn
-
-        for i = 1, N do
-            set(B, F1)
-            set(B, F2)
-            set(B, F3)
-            entities[i] = spawn(B)
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 4 components / builder', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local set = B.set
-        local spawn = B.spawn
-
-        for i = 1, N do
-            set(B, F1)
-            set(B, F2)
-            set(B, F3)
-            set(B, F4)
-            entities[i] = spawn(B)
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 5 components / builder', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local set = B.set
-        local spawn = B.spawn
-
-        for i = 1, N do
-            set(B, F1)
-            set(B, F2)
-            set(B, F3)
-            set(B, F4)
-            set(B, F5)
-            entities[i] = spawn(B)
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-print '----------------------------------------'
-
-basics.describe_bench(string.format('create and destroy %d entities with 1 components / spawn', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local spawn = evo.spawn
-
-        local components = { [F1] = true }
-
-        for i = 1, N do
-            entities[i] = spawn(components)
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 2 components / spawn', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local spawn = evo.spawn
-
-        local components = { [F1] = true, [F2] = true }
-
-        for i = 1, N do
-            entities[i] = spawn(components)
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 3 components / spawn', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local spawn = evo.spawn
-
-        local components = { [F1] = true, [F2] = true, [F3] = true }
-
-        for i = 1, N do
-            entities[i] = spawn(components)
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 4 components / spawn', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local spawn = evo.spawn
-
-        local components = { [F1] = true, [F2] = true, [F3] = true, [F4] = true }
-
-        for i = 1, N do
-            entities[i] = spawn(components)
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 5 components / spawn', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local spawn = evo.spawn
-
-        local components = { [F1] = true, [F2] = true, [F3] = true, [F4] = true, [F5] = true }
-
-        for i = 1, N do
-            entities[i] = spawn(components)
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-print '----------------------------------------'
-
-basics.describe_bench(string.format('create and destroy %d entities with 1 components / clone', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local clone = evo.clone
-
-        local prefab = evo.spawn({ [F1] = true })
-
-        for i = 1, N do
-            entities[i] = clone(prefab)
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 2 components / clone', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local clone = evo.clone
-
-        local prefab = evo.spawn({ [F1] = true, [F2] = true })
-
-        for i = 1, N do
-            entities[i] = clone(prefab)
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 3 components / clone', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local clone = evo.clone
-
-        local prefab = evo.spawn({ [F1] = true, [F2] = true, [F3] = true })
-
-        for i = 1, N do
-            entities[i] = clone(prefab)
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 4 components / clone', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local clone = evo.clone
-
-        local prefab = evo.spawn({ [F1] = true, [F2] = true, [F3] = true, [F4] = true })
-
-        for i = 1, N do
-            entities[i] = clone(prefab)
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 5 components / clone', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local clone = evo.clone
-
-        local prefab = evo.spawn({ [F1] = true, [F2] = true, [F3] = true, [F4] = true, [F5] = true })
-
-        for i = 1, N do
-            entities[i] = clone(prefab)
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-print '----------------------------------------'
-
-basics.describe_bench(string.format('create and destroy %d entities with 1 requires / spawn', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local spawn = evo.spawn
-
-        local components = { [R1] = true }
-
-        for i = 1, N do
-            entities[i] = spawn(components)
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 2 requires / spawn', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local spawn = evo.spawn
-
-        local components = { [R2] = true }
-
-        for i = 1, N do
-            entities[i] = spawn(components)
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 3 requires / spawn', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local spawn = evo.spawn
-
-        local components = { [R3] = true }
-
-        for i = 1, N do
-            entities[i] = spawn(components)
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 4 requires / spawn', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local spawn = evo.spawn
-
-        local components = { [R4] = true }
-
-        for i = 1, N do
-            entities[i] = spawn(components)
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 5 requires / spawn', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local spawn = evo.spawn
-
-        local components = { [R5] = true }
-
-        for i = 1, N do
-            entities[i] = spawn(components)
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-print '----------------------------------------'
-
-basics.describe_bench(string.format('create and destroy %d entities with 1 requires / clone', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local clone = evo.clone
-
-        local prefab = evo.spawn({ [R1] = true })
-
-        for i = 1, N do
-            entities[i] = clone(prefab)
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 2 requires / clone', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local clone = evo.clone
-
-        local prefab = evo.spawn({ [R2] = true })
-
-        for i = 1, N do
-            entities[i] = clone(prefab)
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 3 requires / clone', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local clone = evo.clone
-
-        local prefab = evo.spawn({ [R3] = true })
-
-        for i = 1, N do
-            entities[i] = clone(prefab)
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 4 requires / clone', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local clone = evo.clone
-
-        local prefab = evo.spawn({ [R4] = true })
-
-        for i = 1, N do
-            entities[i] = clone(prefab)
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
-
-basics.describe_bench(string.format('create and destroy %d entities with 5 requires / clone', N),
-    ---@param entities evolved.id[]
-    function(entities)
-        local clone = evo.clone
-
-        local prefab = evo.spawn({ [R5] = true })
-
-        for i = 1, N do
-            entities[i] = clone(prefab)
-        end
-
-        evo.batch_destroy(Q1)
-    end, function()
-        return {}
-    end)
--- a/develop/usbench.lua
+++ b/develop/usbench.lua
@@ -1,374 +0,0 @@
-local basics = require 'develop.basics'
-basics.unload 'evolved'
-
-local evo = require 'evolved'
-local tiny = require 'develop.3rdparty.tiny'
-
-local N = 1000
-
-print '----------------------------------------'
-
-basics.describe_bench(string.format('Tiny Entity Cycle: %d entities', N),
-    function(world)
-        world:update(0.016)
-    end, function()
-        local world = tiny.world()
-
-        for i = 1, N do
-            world:addEntity({ a = i })
-        end
-
-        local A = tiny.processingSystem()
-        A.filter = tiny.requireAll('a')
-        A.process = function(_, e) world:addEntity({ b = e.a }) end
-        A.postProcess = function(_) world:refresh() end
-
-        local B = tiny.processingSystem()
-        B.filter = tiny.requireAll('b')
-        B.process = function(_, e) world:removeEntity(e) end
-        B.postProcess = function(_) world:refresh() end
-
-        world:addSystem(A)
-        world:addSystem(B)
-
-        world:refresh()
-
-        return world
-    end)
-
-basics.describe_bench(string.format('Evolved Entity Cycle (Defer): %d entities', N),
-    function(a, b, A, B)
-        evo.defer()
-        do
-            for chunk, _, entity_count in evo.execute(A) do
-                local as = chunk:components(a)
-                for i = 1, entity_count do
-                    evo.set(evo.id(), b, as[i])
-                end
-            end
-        end
-        evo.commit()
-
-        evo.batch_destroy(B)
-    end, function()
-        local a, b = evo.id(2)
-
-        for i = 1, N do
-            evo.builder():set(a, i):spawn()
-        end
-
-        local A = evo.builder():include(a):spawn()
-        local B = evo.builder():include(b):spawn()
-
-        return a, b, A, B
-    end, function(_, _, A, _)
-        evo.batch_destroy(A)
-    end)
-
-basics.describe_bench(string.format('Evolved Entity Cycle (Manual): %d entities', N),
-    function(a, b, A, B)
-        local to_create = {}
-        local to_create_count = 0
-
-        for chunk, _, entity_count in evo.execute(A) do
-            local as = chunk:components(a)
-            for i = 1, entity_count do
-                to_create_count = to_create_count + 1
-                to_create[to_create_count] = as[i]
-            end
-        end
-
-        for i = 1, to_create_count do
-            local e = evo.id()
-            evo.set(e, b, to_create[i])
-        end
-
-        evo.batch_destroy(B)
-    end, function()
-        local a, b = evo.id(2)
-
-        for i = 1, N do
-            evo.builder():set(a, i):spawn()
-        end
-
-        local A = evo.builder():include(a):spawn()
-        local B = evo.builder():include(b):spawn()
-
-        return a, b, A, B
-    end, function(_, _, A, _)
-        evo.batch_destroy(A)
-    end)
-
-print '----------------------------------------'
-
-basics.describe_bench(string.format('Tiny Simple Iteration: %d entities', N),
-    function(world)
-        world:update(0.016)
-    end, function()
-        local world = tiny.world()
-
-        for i = 1, N do
-            world:addEntity({ a = i, b = i })
-            world:addEntity({ a = i, b = i, c = i })
-            world:addEntity({ a = i, b = i, c = i, d = i })
-            world:addEntity({ a = i, b = i, c = i, e = i })
-        end
-
-        local AB = tiny.processingSystem()
-        AB.filter = tiny.requireAll('a', 'b')
-        AB.process = function(_, e) e.a, e.b = e.b, e.a end
-
-        local CD = tiny.processingSystem()
-        CD.filter = tiny.requireAll('c', 'd')
-        CD.process = function(_, e) e.c, e.d = e.d, e.c end
-
-        local CE = tiny.processingSystem()
-        CE.filter = tiny.requireAll('c', 'e')
-        CE.process = function(_, e) e.c, e.e = e.e, e.c end
-
-        world:addSystem(AB)
-        world:addSystem(CD)
-        world:addSystem(CE)
-
-        world:refresh()
-
-        return world
-    end)
-
-basics.describe_bench(string.format('Evolved Simple Iteration: %d entities', N),
-    ---@param a evolved.entity
-    ---@param b evolved.entity
-    ---@param c evolved.entity
-    ---@param d evolved.entity
-    ---@param e evolved.entity
-    ---@param AB evolved.query
-    ---@param CD evolved.query
-    ---@param CE evolved.query
-    function(a, b, c, d, e, AB, CD, CE)
-        for chunk, _, entity_count in evo.execute(AB) do
-            local as, bs = chunk:components(a, b)
-            for i = 1, entity_count do
-                as[i], bs[i] = bs[i], as[i]
-            end
-        end
-
-        for chunk, _, entity_count in evo.execute(CD) do
-            local cs, ds = chunk:components(c, d)
-            for i = 1, entity_count do
-                cs[i], ds[i] = ds[i], cs[i]
-            end
-        end
-
-        for chunk, _, entity_count in evo.execute(CE) do
-            local cs, es = chunk:components(c, e)
-            for i = 1, entity_count do
-                cs[i], es[i] = es[i], cs[i]
-            end
-        end
-    end, function()
-        local a, b, c, d, e = evo.id(5)
-
-        for i = 1, N do
-            evo.builder():set(a, i):set(b, i):spawn()
-            evo.builder():set(a, i):set(b, i):set(c, i):spawn()
-            evo.builder():set(a, i):set(b, i):set(c, i):set(d, i):spawn()
-            evo.builder():set(a, i):set(b, i):set(c, i):set(e, i):spawn()
-        end
-
-        local AB = evo.builder():include(a, b):spawn()
-        local CD = evo.builder():include(c, d):spawn()
-        local CE = evo.builder():include(c, e):spawn()
-
-        return a, b, c, d, e, AB, CD, CE
-    end, function(_, _, _, _, _, AB, CD, CE)
-        evo.batch_destroy(AB)
-        evo.batch_destroy(CD)
-        evo.batch_destroy(CE)
-    end)
-
-print '----------------------------------------'
-
-basics.describe_bench(string.format('Tiny Packed Iteration: %d entities', N),
-    function(world)
-        world:update(0.016)
-    end, function()
-        local world = tiny.world()
-
-        for i = 1, N do
-            world:addEntity({ a = i, b = i, c = i, d = i, e = i })
-        end
-
-        local A = tiny.processingSystem()
-        A.filter = tiny.requireAll('a')
-        A.process = function(_, e) e.a = e.a * 2 end
-
-        local B = tiny.processingSystem()
-        B.filter = tiny.requireAll('b')
-        B.process = function(_, e) e.b = e.b * 2 end
-
-        local C = tiny.processingSystem()
-        C.filter = tiny.requireAll('c')
-        C.process = function(_, e) e.c = e.c * 2 end
-
-        local D = tiny.processingSystem()
-        D.filter = tiny.requireAll('d')
-        D.process = function(_, e) e.d = e.d * 2 end
-
-        local E = tiny.processingSystem()
-        E.filter = tiny.requireAll('e')
-        E.process = function(_, e) e.e = e.e * 2 end
-
-        world:addSystem(A)
-        world:addSystem(B)
-        world:addSystem(C)
-        world:addSystem(D)
-        world:addSystem(E)
-
-        world:refresh()
-
-        return world
-    end)
-
-basics.describe_bench(string.format('Evolved Packed Iteration: %d entities', N),
-    ---@param a evolved.entity
-    ---@param b evolved.entity
-    ---@param c evolved.entity
-    ---@param d evolved.entity
-    ---@param e evolved.entity
-    ---@param A evolved.query
-    ---@param B evolved.query
-    ---@param C evolved.query
-    ---@param D evolved.query
-    ---@param E evolved.query
-    function(a, b, c, d, e, A, B, C, D, E)
-        for chunk, _, entity_count in evo.execute(A) do
-            local as = chunk:components(a)
-            for i = 1, entity_count do
-                as[i] = as[i] * 2
-            end
-        end
-
-        for chunk, _, entity_count in evo.execute(B) do
-            local bs = chunk:components(b)
-            for i = 1, entity_count do
-                bs[i] = bs[i] * 2
-            end
-        end
-
-        for chunk, _, entity_count in evo.execute(C) do
-            local cs = chunk:components(c)
-            for i = 1, entity_count do
-                cs[i] = cs[i] * 2
-            end
-        end
-
-        for chunk, _, entity_count in evo.execute(D) do
-            local ds = chunk:components(d)
-            for i = 1, entity_count do
-                ds[i] = ds[i] * 2
-            end
-        end
-
-        for chunk, _, entity_count in evo.execute(E) do
-            local es = chunk:components(e)
-            for i = 1, entity_count do
-                es[i] = es[i] * 2
-            end
-        end
-    end, function()
-        local a, b, c, d, e = evo.id(5)
-
-        for i = 1, N do
-            evo.builder():set(a, i):set(b, i):set(c, i):set(d, i):set(e, i):spawn()
-        end
-
-        local A = evo.builder():include(a):spawn()
-        local B = evo.builder():include(b):spawn()
-        local C = evo.builder():include(c):spawn()
-        local D = evo.builder():include(d):spawn()
-        local E = evo.builder():include(e):spawn()
-
-        return a, b, c, d, e, A, B, C, D, E
-    end, function(_, _, _, _, _, A, _, _, _, _)
-        evo.batch_destroy(A)
-    end)
-
-print '----------------------------------------'
-
-basics.describe_bench(string.format('Tiny Fragmented Iteration: %d entities', N),
-    function(world)
-        world:update(0.016)
-    end, function()
-        local world = tiny.world()
-
-        ---@type string[]
-        local chars = {}
-
-        for i = 1, 26 do
-            chars[i] = string.char(string.byte('a') + i - 1)
-        end
-
-        for _, char in ipairs(chars) do
-            for i = 1, N do
-                world:addEntity({ [char] = i, data = i })
-            end
-        end
-
-        local Data = tiny.processingSystem()
-        Data.filter = tiny.requireAll('data')
-        Data.process = function(_, e) e.data = e.data * 2 end
-
-        local Last = tiny.processingSystem()
-        Last.filter = tiny.requireAll('z')
-        Last.process = function(_, e) e.z = e.z * 2 end
-
-        world:addSystem(Data)
-        world:addSystem(Last)
-
-        world:refresh()
-
-        return world
-    end)
-
-basics.describe_bench(string.format('Evolved Fragmented Iteration: %d entities', N),
-    ---@param data evolved.entity
-    ---@param last evolved.entity
-    ---@param Data evolved.query
-    ---@param Last evolved.query
-    function(data, last, Data, Last)
-        for chunk, _, entity_count in evo.execute(Data) do
-            local ds = chunk:components(data)
-            for i = 1, entity_count do
-                ds[i] = ds[i] * 2
-            end
-        end
-
-        for chunk, _, entity_count in evo.execute(Last) do
-            local ls = chunk:components(last)
-            for i = 1, entity_count do
-                ls[i] = ls[i] * 2
-            end
-        end
-    end, function()
-        local data = evo.id()
-
-        ---@type evolved.fragment[]
-        local chars = {}
-
-        for i = 1, 26 do
-            chars[i] = evo.id()
-        end
-
-        for _, char in ipairs(chars) do
-            for i = 1, N do
-                evo.builder():set(char, i):set(data, i):spawn()
-            end
-        end
-
-        local Data = evo.builder():include(data):spawn()
-        local Last = evo.builder():include(chars[#chars]):spawn()
-
-        return data, chars[#chars], Data, Last
-    end, function(_, _, Data, _)
-        evo.batch_destroy(Data)
-    end)
--- a/evolved.d.tl
+++ b/evolved.d.tl
@@ -0,0 +1,181 @@
+local record Evolved
+    interface Id end
+
+    type Entity = Id
+    type Fragment = Id
+    type Query = Id
+    type System = Id
+
+    interface EachState end
+    interface ExecuteState end
+
+    type EachIterator = function(state?: EachState): Fragment, any
+    type ExecuteIterator = function(state?: ExecuteState): Chunk, { Entity }, integer
+
+    interface Chunk
+        alive: function(self: Chunk): boolean
+        empty: function(self: Chunk): boolean
+
+        has: function(self: Chunk, fragment: Fragment): boolean
+        has_all: function(self: Chunk, ...: Fragment): boolean
+        has_any: function(self: Chunk, ...: Fragment): boolean
+
+        entities: function(self: Chunk): { Entity }, integer
+        fragments: function(self: Chunk): { Fragment }, integer
+
+        components: function(self: Chunk)
+        components: function<C1>(self: Chunk, f1: Fragment): { C1 }
+        components: function<C1, C2>(self: Chunk, f1: Fragment, f2: Fragment): { C1 }, { C2 }
+        components: function<C1, C2, C3>(self: Chunk, f1: Fragment, f2: Fragment, f3: Fragment): { C1 }, { C2 }, { C3 }
+        components: function<C1, C2, C3, C4>(self: Chunk, f1: Fragment, f2: Fragment, f3: Fragment, f4: Fragment): { C1 }, { C2 }, { C3 }, { C4 }
+    end
+
+    interface Builder
+        build: function(self: Builder, prefab?: Entity): Entity
+        multi_build: function(self: Builder, entity_count: integer, prefab?: Entity): { Entity }, integer
+
+        spawn: function(self: Builder): Entity
+        multi_spawn: function(self: Builder, entity_count: integer): { Entity }, integer
+
+        clone: function(self: Builder, prefab: Entity): Entity
+        multi_clone: function(self: Builder, entity_count: integer, prefab: Entity): { Entity }, integer
+
+        has: function(self: Builder, fragment: Fragment): boolean
+        has_all: function(self: Builder, ...: Fragment): boolean
+        has_any: function(self: Builder, ...: Fragment): boolean
+
+        get: function(self: Builder)
+        get: function<C1>(self: Builder, f1: Fragment): C1 | nil
+        get: function<C1, C2>(self: Builder, f1: Fragment, f2: Fragment): C1 | nil, C2 | nil
+        get: function<C1, C2, C3>(self: Builder, f1: Fragment, f2: Fragment, f3: Fragment): C1 | nil, C2 | nil, C3 | nil
+        get: function<C1, C2, C3, C4>(self: Builder, f1: Fragment, f2: Fragment, f3: Fragment, f4: Fragment): C1 | nil, C2 | nil, C3 | nil, C4 | nil
+
+        set: function<Component>(self: Builder, fragment: Fragment, component?: Component): Builder
+        remove: function(self: Builder, ...: Fragment): Builder
+        clear: function(self: Builder): Builder
+
+        tag: function(self: Builder): Builder
+        name: function(self: Builder, name: string): Builder
+
+        unique: function(self: Builder): Builder
+        explicit: function(self: Builder): Builder
+        internal: function(self: Builder): Builder
+
+        default: function<Component>(self: Builder, default: Component): Builder
+        duplicate: function<Component>(self: Builder, duplicate: function(Component): Component): Builder
+
+        prefab: function(self: Builder): Builder
+        disabled: function(self: Builder): Builder
+
+        include: function(self: Builder, ...: Fragment): Builder
+        exclude: function(self: Builder, ...: Fragment): Builder
+        require: function(self: Builder, ...: Fragment): Builder
+
+        on_set: function<Component>(self: Builder, on_set: function(Entity, Fragment, ? Component, ? Component)): Builder
+        on_assign: function<Component>(self: Builder, on_assign: function(Entity, Fragment, ? Component, ? Component)): Builder
+        on_insert: function<Component>(self: Builder, on_insert: function(Entity, Fragment, ? Component)): Builder
+        on_remove: function<Component>(self: Builder, on_remove: function(Entity, Fragment, ? Component)): Builder
+
+        group: function(self: Builder, group: System): Builder
+
+        query: function(self: Builder, query: Query): Builder
+        execute: function(self: Builder, execute: function(Chunk, {Entity}, integer)): Builder
+
+        prologue: function(self: Builder, prologue: function()): Builder
+        epilogue: function(self: Builder, epilogue: function()): Builder
+
+        destruction_policy: function(self: Builder, destruction_policy: Id): Builder
+    end
+
+    TAG: Fragment
+    NAME: Fragment
+
+    UNIQUE: Fragment
+    EXPLICIT: Fragment
+    INTERNAL: Fragment
+
+    DEFAULT: Fragment
+    DUPLICATE: Fragment
+
+    PREFAB: Fragment
+    DISABLED: Fragment
+
+    INCLUDES: Fragment
+    EXCLUDES: Fragment
+    REQUIRES: Fragment
+
+    ON_SET: Fragment
+    ON_ASSIGN: Fragment
+    ON_INSERT: Fragment
+    ON_REMOVE: Fragment
+
+    GROUP: Fragment
+
+    QUERY: Fragment
+    EXECUTE: Fragment
+    PROLOGUE: Fragment
+    EPILOGUE: Fragment
+
+    DESTRUCTION_POLICY: Fragment
+    DESTRUCTION_POLICY_DESTROY_ENTITY: Id
+    DESTRUCTION_POLICY_REMOVE_FRAGMENT: Id
+
+    id: function(count?: integer): Id...
+    name: function(...: Id): string...
+
+    pack: function(primary: integer, secondary: integer): Id
+    unpack: function(id: Id): integer, integer
+
+    defer: function(): boolean
+    commit: function(): boolean
+    cancel: function(): boolean
+
+    spawn: function(components?: { Fragment: any }): Entity
+    multi_spawn: function(entity_count: integer, components?: { Fragment: any }): { Entity }, integer
+
+    clone: function(prefab: Entity, components?: { Fragment: any }): Entity
+    multi_clone: function(entity_count: integer, prefab: Entity, components?: { Fragment: any }): { Entity }, integer
+
+    alive: function(entity: Entity): boolean
+    alive_all: function(...: Entity): boolean
+    alive_any: function(...: Entity): boolean
+
+    empty: function(entity: Entity): boolean
+    empty_all: function(...: Entity): boolean
+    empty_any: function(...: Entity): boolean
+
+    has: function(entity: Entity, fragment: Fragment): boolean
+    has_all: function(entity: Entity, ...: Fragment): boolean
+    has_any: function(entity: Entity, ...: Fragment): boolean
+
+    get: function(entity: Entity)
+    get: function<C1>(entity: Entity, f1: Fragment): C1 | nil
+    get: function<C1, C2>(entity: Entity, f1: Fragment, f2: Fragment): C1 | nil, C2 | nil
+    get: function<C1, C2, C3>(entity: Entity, f1: Fragment, f2: Fragment, f3: Fragment): C1 | nil, C2 | nil, C3 | nil
+    get: function<C1, C2, C3, C4>(entity: Entity, f1: Fragment, f2: Fragment, f3: Fragment, f4: Fragment): C1 | nil, C2 | nil, C3 | nil, C4 | nil
+
+    set: function<Component>(entity: Entity, fragment: Fragment, component?: Component)
+    remove: function(entity: Entity, ...: Fragment)
+    clear: function(...: Entity)
+    destroy: function(...: Entity)
+
+    batch_set: function<Component>(query: Query, fragment: Fragment, component?: Component)
+    batch_remove: function(query: Query, ...: Fragment)
+    batch_clear: function(...: Query)
+    batch_destroy: function(...: Query)
+
+    each: function(entity: Entity): EachIterator, EachState | nil
+    execute: function(query: Query): ExecuteIterator, ExecuteState | nil
+
+    locate: function(entity: Entity): Chunk | nil, integer
+
+    process: function(...: System)
+
+    debug_mode: function(yesno: boolean)
+    collect_garbage: function()
+
+    chunk: function(fragment: Fragment, ...: Fragment): Chunk, { Entity }, integer
+    builder: function(): Builder
+end
+
+return Evolved
--- a/evolved.lua
+++ b/evolved.lua
--- a/rockspecs/evolved.lua-1.2.0-0.rockspec
+++ b/rockspecs/evolved.lua-1.2.0-0.rockspec
@@ -0,0 +1,34 @@
+rockspec_format = "3.0"
+package = "evolved.lua"
+version = "1.2.0-0"
+source = {
+   url = "git://github.com/BlackMATov/evolved.lua",
+   tag = "v1.2.0",
+}
+description = {
+   homepage = "https://github.com/BlackMATov/evolved.lua",
+   summary = "Evolved ECS (Entity-Component-System) for Lua",
+   detailed = [[
+      `evolved.lua` is a fast and flexible ECS (Entity-Component-System) library for Lua.
+      It is designed to be simple and easy to use, while providing all the features needed to create complex systems with blazing performance.
+   ]],
+   license = "MIT",
+   labels = {
+      "ecs",
+      "entity",
+      "entities",
+      "component",
+      "components",
+      "entity-component",
+      "entity-component-system",
+   },
+}
+dependencies = {
+   "lua >= 5.1",
+}
+build = {
+   type = "builtin",
+   modules = {
+      evolved = "evolved.lua",
+   }
+}
--- a/rockspecs/evolved.lua-1.3.0-0.rockspec
+++ b/rockspecs/evolved.lua-1.3.0-0.rockspec
@@ -0,0 +1,34 @@
+rockspec_format = "3.0"
+package = "evolved.lua"
+version = "1.3.0-0"
+source = {
+   url = "git://github.com/BlackMATov/evolved.lua",
+   tag = "v1.3.0",
+}
+description = {
+   homepage = "https://github.com/BlackMATov/evolved.lua",
+   summary = "Evolved ECS (Entity-Component-System) for Lua",
+   detailed = [[
+      `evolved.lua` is a fast and flexible ECS (Entity-Component-System) library for Lua.
+      It is designed to be simple and easy to use, while providing all the features needed to create complex systems with blazing performance.
+   ]],
+   license = "MIT",
+   labels = {
+      "ecs",
+      "entity",
+      "entities",
+      "component",
+      "components",
+      "entity-component",
+      "entity-component-system",
+   },
+}
+dependencies = {
+   "lua >= 5.1",
+}
+build = {
+   type = "builtin",
+   modules = {
+      evolved = "evolved.lua",
+   }
+}
--- a/rockspecs/evolved.lua-1.4.0-0.rockspec
+++ b/rockspecs/evolved.lua-1.4.0-0.rockspec
@@ -0,0 +1,34 @@
+rockspec_format = "3.0"
+package = "evolved.lua"
+version = "1.4.0-0"
+source = {
+   url = "git://github.com/BlackMATov/evolved.lua",
+   tag = "v1.4.0",
+}
+description = {
+   homepage = "https://github.com/BlackMATov/evolved.lua",
+   summary = "Evolved ECS (Entity-Component-System) for Lua",
+   detailed = [[
+      `evolved.lua` is a fast and flexible ECS (Entity-Component-System) library for Lua.
+      It is designed to be simple and easy to use, while providing all the features needed to create complex systems with blazing performance.
+   ]],
+   license = "MIT",
+   labels = {
+      "ecs",
+      "entity",
+      "entities",
+      "component",
+      "components",
+      "entity-component",
+      "entity-component-system",
+   },
+}
+dependencies = {
+   "lua >= 5.1",
+}
+build = {
+   type = "builtin",
+   modules = {
+      evolved = "evolved.lua",
+   }
+}
Author	SHA1	Message	Date
BlackMATov	760b477564	update changelog	2025-11-21 06:31:42 +07:00
BlackMATov	fc910881bd	cache defaults/duplicates per chunk, use it for spawn/clone ops	2025-11-21 05:37:14 +07:00
BlackMATov	71a7c84a67	add spawn/clone with defaults bmarks	2025-11-20 16:19:13 +07:00
BlackMATov	582a09a6db	additional spawn/clone tests	2025-11-20 05:00:52 +07:00
BlackMATov	de73881f63	improve performance of the clone operations	2025-11-19 08:51:26 +07:00
BlackMATov	55e444ca63	improve performance of the spawn operations	2025-11-19 02:23:48 +07:00
BlackMATov	e499c701ef	add defer clone bmarks	2025-11-12 23:44:34 +07:00
BlackMATov	789f167bf4	add defer spawn bmarks	2025-11-12 16:47:38 +07:00
BlackMATov	00367ce07e	Merge branch 'feature/teal' into dev	2025-11-08 01:34:29 +07:00
BlackMATov	07902eb184	teal definitions cleanup	2025-11-07 23:26:45 +07:00
Matvey Cherevko	ecdbfe660f	Merge pull request #30 from p0sel0k/main	2025-11-07 16:03:22 +07:00
p0sel0k	cfd68767cf	fix: set and batch_set component argument should be optional	2025-11-04 21:57:00 +03:00
p0sel0k	f1ba9ab909	fix: replace number type with integer; EachState\ExecuteState records	2025-11-04 18:56:02 +03:00
BlackMATov	77ff3e77db	readme: internal fragments https://github.com/BlackMATov/evolved.lua/issues/28	2025-11-04 21:00:22 +07:00
p0sel0k	825eba5328	fix: remove teal types for internal usage	2025-11-04 10:06:01 +03:00
p0sel0k	67002503ed	fix: removed IComponent and added generics for functions and hooks that take Component as a single argument	2025-11-03 11:57:18 +03:00
p0sel0k	1bb0089e9f	fix: functions arguments naming	2025-11-02 21:21:25 +03:00
p0sel0k	dc642f5294	fix: fixes after review	2025-11-02 21:12:26 +03:00
p0sel0k	a81a8646e9	fix: wrong file name	2025-10-29 19:29:56 +03:00
p0sel0k	aa6d2c1c48	feat: add Teal language definitions	2025-10-29 19:24:07 +03:00
BlackMATov	5fe48de890	little speed up of exclude-only queries	2025-10-29 22:57:58 +07:00
Matvey Cherevko	0d7adcb5fd	Merge pull request #27 from BlackMATov/dev Dev	2025-10-20 16:16:39 +07:00
BlackMATov	f48f1bb290	v1.4.0	2025-10-20 16:11:03 +07:00
BlackMATov	6f1a85165f	more tests	2025-10-16 06:22:30 +07:00
BlackMATov	bd87e593e9	root directory cleanup	2025-10-14 17:50:51 +07:00
BlackMATov	0eac310fd5	style fixes	2025-10-12 23:35:28 +07:00
BlackMATov	22cedd26bb	remove some of the specialized defer functions in favor of the universal defer_call_hook	2025-10-12 07:04:44 +07:00
BlackMATov	d298be4188	ON_REMOVE hooks are now invoked before the fragment is actually removed from the entity issue: https://github.com/BlackMATov/evolved.lua/issues/26	2025-10-12 06:46:43 +07:00
BlackMATov	24933e6a04	little internal hooks refactoring	2025-10-08 16:18:49 +07:00
BlackMATov	6841bb42fe	style fixes	2025-10-07 22:56:29 +07:00
BlackMATov	dc912eb6da	the universal builder:build/multi_build methods	2025-10-06 19:05:16 +07:00
BlackMATov	8d3c4633fb	little coverage upping	2025-10-06 16:53:53 +07:00
BlackMATov	8704fb0c39	update changelog	2025-10-06 04:46:14 +07:00
BlackMATov	86c9ef7cf2	caching exclude-only queries was a mistake	2025-10-06 04:38:06 +07:00
BlackMATov	bd5f9bb61f	cache exclude-only queries too	2025-10-06 02:53:38 +07:00
BlackMATov	cfa5dc7a9f	lazy query chunks updating	2025-10-06 01:46:54 +07:00
BlackMATov	243adc1a93	fix query cache reset	2025-10-05 09:13:59 +07:00
BlackMATov	cf19fba9e4	cache query major chunks: first impl	2025-10-05 08:59:07 +07:00
BlackMATov	784b9c6a15	delele some unnecessary checks	2025-09-29 15:20:37 +07:00
Matvey Cherevko	2903b077fe	Merge pull request #24 from BlackMATov/dev Dev	2025-09-26 17:30:35 +07:00
BlackMATov	d3b14a6741	v1.3.0	2025-09-26 17:27:49 +07:00
BlackMATov	fdf5a03a02	improve performance of builders that are used for spawning multiple times	2025-09-26 17:21:50 +07:00
BlackMATov	9221da6ea7	slightly improve required fragments perf	2025-09-24 18:16:01 +07:00
BlackMATov	0aa57f6b5b	benchmarks refactoring 2	2025-09-24 00:51:25 +07:00
BlackMATov	7e38e43d7c	benchmarks refactoring	2025-09-23 17:37:29 +07:00
BlackMATov	b1b627b677	improve perf of cloning prefabs with many unique fragments	2025-09-23 07:53:11 +07:00
BlackMATov	281866cf6e	set/assign hooks are not invoked for tags on override operations anymore	2025-09-23 07:24:26 +07:00
BlackMATov	4ad7fec26d	update readme	2025-09-23 05:05:30 +07:00
BlackMATov	f15118be05	the new evolved.locate public function ref: #23	2025-09-23 04:58:10 +07:00
BlackMATov	964ea45f48	use xpcall to process systems	2025-09-22 21:27:57 +07:00
BlackMATov	b2c08e1127	cancel deferring ops in systems on error	2025-09-22 05:51:21 +07:00
BlackMATov	2250bd64ce	the new evolved.cancel public function	2025-09-22 02:34:37 +07:00
BlackMATov	e564be46fb	collect garbage from old bytecode	2025-09-22 01:56:08 +07:00
BlackMATov	521ad94278	the internal garbage collector now collects more garbage	2025-09-20 03:11:12 +07:00
BlackMATov	7f6909e48c	remove some unused code about pinned chunks	2025-09-20 01:53:29 +07:00
BlackMATov	ec745f6ad7	Merge branch 'feature/schemes' into dev	2025-09-19 19:51:02 +07:00
BlackMATov	b3eec59f8b	update readme	2025-09-19 19:50:50 +07:00
BlackMATov	1635dd66b1	remove schemes temporary	2025-09-19 18:58:18 +07:00
BlackMATov	b420085ed5	proof of concept ffi component storages fast batch ops storage swapping was temporary removed	2025-09-19 07:04:19 +07:00
BlackMATov	6d5f810d45	experimental scheme creation	2025-09-15 17:56:44 +07:00
BlackMATov	5447f50090	dummy SCHEME class and readme	2025-09-12 05:58:41 +07:00
BlackMATov	e6d79dc600	Merge branch 'dev' into feature/schemes	2025-09-12 05:45:33 +07:00
Matvey Cherevko	7b6ac89c8a	Merge pull request #21 from BlackMATov/dev Dev	2025-09-12 05:30:07 +07:00
BlackMATov	91b3910eda	v1.2.0	2025-09-12 05:27:17 +07:00
BlackMATov	7f5ac62a79	Merge branch 'feature/multi_spawn' into dev	2025-09-12 05:13:55 +07:00
BlackMATov	327a6bcbce	final tweaks of the multi_spawn/clone functions	2025-09-12 05:11:29 +07:00
BlackMATov	5184b39f4e	proof of concept multi_clone/spawn optimizations	2025-09-12 01:52:33 +07:00
BlackMATov	de7d1a6674	dirty proof of concept multi_spawn impl (without any optimization)	2025-09-11 06:57:13 +07:00
BlackMATov	632232b9b1	dummy multi spawn api	2025-09-11 01:27:54 +07:00
BlackMATov	fbc61a8895	style fixes	2025-09-10 16:27:50 +07:00
BlackMATov	e3ed2d89a6	style fixes	2025-09-09 14:46:54 +07:00
BlackMATov	bb7f469288	inline internal ids unpacking	2025-09-09 05:02:27 +07:00
BlackMATov	8417cecbbe	little test fixes	2025-09-08 17:42:31 +07:00
BlackMATov	eb31ed247b	little test fixes	2025-09-08 17:41:18 +07:00
BlackMATov	9400401161	dummy SCHEME fragment trait	2025-09-03 15:07:32 +07:00
BlackMATov	59fb4d8ea4	update readme	2025-09-01 16:09:35 +07:00
BlackMATov	001e6f2956	Merge branch 'feature/pairs' into dev	2025-09-01 15:49:46 +07:00
Matvey Cherevko	6bf13890ef	Merge pull request #14 from BlackMATov/dev Dev	2025-06-06 21:28:17 +07:00
Matvey Cherevko	db191b805f	Merge pull request #13 from BlackMATov/dev Dev	2025-05-23 20:07:43 +07:00
Matvey Cherevko	5ab963022c	Merge pull request #12 from BlackMATov/dev Dev	2025-05-21 20:48:59 +07:00
Matvey Cherevko	7de95207d6	Merge pull request #11 from BlackMATov/dev Dev	2025-05-21 17:34:13 +07:00
Matvey Cherevko	4d3b909efb	Merge pull request #10 from BlackMATov/dev Dev	2025-05-21 06:20:38 +07:00
Matvey Cherevko	52b3cbeb20	Merge pull request #9 from BlackMATov/dev Dev	2025-05-21 03:38:16 +07:00
Matvey Cherevko	fec193f4f0	Merge pull request #8 from BlackMATov/dev Dev	2025-05-21 02:11:39 +07:00
Matvey Cherevko	e672b0291a	Merge pull request #7 from BlackMATov/dev Dev	2025-05-02 07:28:38 +07:00
Matvey Cherevko	4624f2e603	Merge pull request #6 from BlackMATov/dev Dev	2025-04-30 23:47:13 +07:00
Matvey Cherevko	c25769f64f	Merge pull request #5 from BlackMATov/dev Dev	2025-04-19 18:40:25 +07:00
Matvey Cherevko	d7274765cb	Merge pull request #4 from BlackMATov/dev Dev	2025-04-09 03:04:19 +07:00
Matvey Cherevko	ef033e7a0c	Merge pull request #3 from BlackMATov/dev Dev	2025-04-09 00:58:14 +07:00
Matvey Cherevko	3638dedca5	Merge pull request #2 from BlackMATov/dev Dev	2025-04-06 21:27:33 +07:00
Matvey Cherevko	d025ea039b	Merge pull request #1 from BlackMATov/dev Dev	2025-04-05 02:12:18 +07:00
BlackMATov	6c0df71f17	Merge branch 'dev'	2025-03-27 15:36:58 +07:00
BlackMATov	730bffc3ad	Merge branch 'dev'	2025-03-19 06:52:10 +07:00
BlackMATov	4bbd7ee60a	Merge branch 'dev'	2025-03-18 07:08:27 +07:00
BlackMATov	79aecc8db3	Merge branch 'dev'	2025-03-17 00:23:36 +07:00
BlackMATov	b803faea63	Merge branch 'dev'	2025-03-16 07:46:26 +07:00
BlackMATov	722eda0b9b	Merge branch 'dev'	2025-03-16 02:06:17 +07:00
BlackMATov	c6def51830	Merge branch 'dev'	2025-03-10 08:14:38 +07:00
BlackMATov	65312f79dd	Merge branch 'dev'	2025-03-08 06:07:06 +07:00
BlackMATov	9877e41705	Merge branch 'dev'	2025-03-02 12:09:33 +07:00
BlackMATov	3b8367d5c4	Merge branch 'dev'	2025-02-24 06:06:26 +07:00
BlackMATov	419a6b6c45	Merge branch 'dev'	2025-02-23 03:54:56 +07:00
BlackMATov	368b50770c	Merge branch 'dev'	2025-02-22 00:31:27 +07:00
BlackMATov	0d49802235	Merge branch 'dev'	2025-02-08 04:52:56 +07:00
BlackMATov	f096d747f3	Merge branch 'dev'	2025-01-31 22:14:13 +07:00
BlackMATov	4d88063c10	Merge branch 'dev'	2025-01-31 12:51:30 +07:00
BlackMATov	bf135534c0	Merge branch 'dev'	2025-01-25 08:37:55 +07:00
BlackMATov	177ea7f180	Merge branch 'dev'	2025-01-21 10:52:19 +07:00
BlackMATov	b98b5f9c42	Merge branch 'dev'	2025-01-18 01:39:27 +07:00
BlackMATov	c7120e8608	opt: get chunk by fragments without sorting	2025-01-16 06:42:03 +07:00